1
          
          require 'open3'
        
      
        

          
          
          
        
      
        

          1
          
          class Bash
        
      
        

          
          
          
        
      
        

          1
          
            def run(command)
        
      
        

          250
          
              stdout,stderr,r = Open3.capture3(command)
        
      
        

          248
          
              [ stdout, stderr, r.exitstatus ]
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          
          
          
        
      
        

          1
          
          module Empty
        
      
        

          1
          
            def self.binding
        
      
        

          68
          
              super
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          
          
          # frozen_string_literal: true
        
      
        

          1
          
          require_relative 'bash'
        
      
        

          1
          
          require_relative 'log'
        
      
        

          1
          
          require_relative 'shell'
        
      
        

          
          
          
        
      
        

          1
          
          class Externals
        
      
        

          
          
          
        
      
        

          1
          
            def initialize(options = {})
        
      
        

          86
          
              @bash = options['bash'] || Bash.new
        
      
        

          86
          
              @log = options['log'] || Log.new
        
      
        

          86
          
              @shell = Shell.new(self)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            attr_reader :bash, :log, :shell
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          
          
          # frozen_string_literal: true
        
      
        

          1
          
          module FilesDelta
        
      
        

          
          
          
        
      
        

          1
          
            def files_delta(was, now)
        
      
        

          76
          
              changed = {}
        
      
        

          76
          
              deleted = []
        
      
        

          76
          
              was.each do |filename, content|
        
      
        

          236
          
                if !now.has_key?(filename)
        
      
        

          13
          
                  deleted << filename
        
      
        

          223
          
                elsif now[filename]['content'] != content
        
      
        

          3
          
                  changed[filename] = now[filename]
        
      
        

          
          
                end
        
      
        

          236
          
                now.delete(filename) # destructive
        
      
        

          
          
              end
        
      
        

          76
          
              created = now
        
      
        

          76
          
              [created,deleted.sort,changed]
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          require 'stringio'
        
      
        

          1
          
          require 'zlib'
        
      
        

          
          
          
        
      
        

          1
          
          module Gnu
        
      
        

          
          
          
        
      
        

          1
          
            def self.unzip(s)
        
      
        

          72
          
              reader = Zlib::GzipReader.new(StringIO.new(s))
        
      
        

          72
          
              unzipped = reader.read
        
      
        

          72
          
              reader.close
        
      
        

          72
          
              unzipped
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          require 'stringio'
        
      
        

          1
          
          require 'zlib'
        
      
        

          
          
          
        
      
        

          1
          
          module Gnu
        
      
        

          
          
          
        
      
        

          1
          
            def self.zip(s)
        
      
        

          80
          
              zipped = StringIO.new('')
        
      
        

          80
          
              writer = Zlib::GzipWriter.new(zipped)
        
      
        

          80
          
              writer.write(s)
        
      
        

          80
          
              writer.close
        
      
        

          80
          
              zipped.string
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          
          
          # frozen_string_literal: true
        
      
        

          1
          
          require 'json'
        
      
        

          
          
          
        
      
        

          1
          
          class HttpJsonArgs
        
      
        

          
          
          
        
      
        

          1
          
            class Error < RuntimeError
        
      
        

          1
          
              def initialize(message)
        
      
        

          28
          
                super
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            def initialize(body)
        
      
        

          35
          
              @args = json_parse(body)
        
      
        

          29
          
              unless @args.is_a?(Hash)
        
      
        

          12
          
                raise request_error('body is not JSON Hash')
        
      
        

          
          
              end
        
      
        

          
          
            rescue JSON::ParserError
        
      
        

          6
          
              raise request_error('body is not JSON')
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            def get(path)
        
      
        

          17
          
              case path
        
      
        

          1
          
              when '/sha'                then ['sha',[]]
        
      
        

          1
          
              when '/alive'              then ['alive?',[]]
        
      
        

          2
          
              when '/ready'              then ['ready?',[]]
        
      
        

          7
          
              when '/run_cyber_dojo_sh'  then ['run_cyber_dojo_sh',[image_name, id, files, max_seconds]]
        
      
        

          
          
              else
        
      
        

          6
          
                raise request_error('unknown path')
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            private
        
      
        

          
          
          
        
      
        

          1
          
            def json_parse(body)
        
      
        

          35
          
              if body === ''
        
      
        

          1
          
                {}
        
      
        

          
          
              else
        
      
        

          34
          
                JSON.parse(body)
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            def image_name
        
      
        

          7
          
              exists_arg('image_name')
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            def id
        
      
        

          6
          
              exists_arg('id')
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            def files
        
      
        

          5
          
              exists_arg('files')
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            def max_seconds
        
      
        

          4
          
              exists_arg('max_seconds')
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            def exists_arg(name)
        
      
        

          22
          
              unless @args.has_key?(name)
        
      
        

          4
          
                raise missing(name)
        
      
        

          
          
              end
        
      
        

          18
          
              arg = @args[name]
        
      
        

          18
          
              arg
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            def missing(arg_name)
        
      
        

          4
          
              request_error("#{arg_name} is missing")
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            def request_error(text)
        
      
        

          
          
              # Exception messages use the words 'body' and 'path'
        
      
        

          
          
              # to match RackDispatcher's exception keys.
        
      
        

          28
          
              HttpJsonArgs::Error.new(text)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          
          
          # frozen_string_literal: true
        
      
        

          1
          
          class Log
        
      
        

          
          
          
        
      
        

          1
          
            def <<(message)
        
      
        

          12
          
              $stdout.print(message)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          
          
          # frozen_string_literal: true
        
      
        

          1
          
          require_relative 'http_json_args'
        
      
        

          1
          
          require_relative 'runner'
        
      
        

          1
          
          require 'rack'
        
      
        

          1
          
          require 'json'
        
      
        

          
          
          
        
      
        

          1
          
          class RackDispatcher
        
      
        

          
          
          
        
      
        

          1
          
            def initialize(externals)
        
      
        

          35
          
              @externals = externals
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def call(env, request_class = Rack::Request)
        
      
        

          35
          
              request = request_class.new(env)
        
      
        

          35
          
              path = request.path_info
        
      
        

          35
          
              body = request.body.read
        
      
        

          35
          
              name,args = HttpJsonArgs.new(body).get(path)
        
      
        

          7
          
              runner = Runner.new(@externals)
        
      
        

          7
          
              result = runner.public_send(name, *args)
        
      
        

          6
          
              json_response_pass(200, result)
        
      
        

          
          
            rescue HttpJsonArgs::Error => error
        
      
        

          28
          
              json_response_fail(400, diagnostic(path, body, error))
        
      
        

          
          
            rescue Exception => error
        
      
        

          1
          
              json_response_fail(500, diagnostic(path, body, error))
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            private
        
      
        

          
          
          
        
      
        

          1
          
            def json_response_pass(status, json)
        
      
        

          6
          
              s = JSON.fast_generate(json)
        
      
        

          6
          
              [ status, CONTENT_TYPE_JSON, [s] ]
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            def json_response_fail(status, json)
        
      
        

          29
          
              s = JSON.pretty_generate(json)
        
      
        

          29
          
              $stderr.puts(s)
        
      
        

          29
          
              $stderr.flush
        
      
        

          29
          
              [ status, CONTENT_TYPE_JSON, [s] ]
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            def diagnostic(path, body, error)
        
      
        

          29
          
              { 'exception' => {
        
      
        

          
          
                  'path' => path,
        
      
        

          
          
                  'body' => body,
        
      
        

          
          
                  'class' => 'RunnerService',
        
      
        

          
          
                  'message' => error.message,
        
      
        

          
          
                  'backtrace' => error.backtrace
        
      
        

          
          
                }
        
      
        

          
          
              }
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            CONTENT_TYPE_JSON = { 'Content-Type' => 'application/json' }
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          
          
          # frozen_string_literal: true
        
      
        

          1
          
          require_relative 'files_delta'
        
      
        

          1
          
          require_relative 'gnu_unzip'
        
      
        

          1
          
          require_relative 'gnu_zip'
        
      
        

          1
          
          require_relative 'tar_reader'
        
      
        

          1
          
          require_relative 'tar_writer'
        
      
        

          1
          
          require_relative 'traffic_light'
        
      
        

          1
          
          require_relative 'utf8_clean'
        
      
        

          1
          
          require 'securerandom'
        
      
        

          1
          
          require 'timeout'
        
      
        

          
          
          
        
      
        

          1
          
          class Runner
        
      
        

          
          
          
        
      
        

          1
          
            def initialize(externals)
        
      
        

          71
          
              @externals = externals
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            def sha
        
      
        

          2
          
              { 'sha' => ENV['SHA'] }
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def alive?
        
      
        

          2
          
              { 'alive?' => true }
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def ready?
        
      
        

          3
          
              { 'ready?' => true }
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            def run_cyber_dojo_sh(image_name, id, files, max_seconds)
        
      
        

          
          
              # [X] Assumes image_name was built by image_builder with a
        
      
        

          
          
              # Dockerfile augmented by image_dockerfile_augmenter. See
        
      
        

          
          
              #   https://github.com/cyber-dojo-languages/image_builder
        
      
        

          
          
              #   https://github.com/cyber-dojo-languages/image_dockerfile_augmenter
        
      
        

          80
          
              @result = {}
        
      
        

          80
          
              create_container(image_name, id, max_seconds+2)
        
      
        

          
          
              begin
        
      
        

          79
          
                run(files, max_seconds)
        
      
        

          79
          
                text_file_changes(files)
        
      
        

          79
          
                traffic_light(image_name, id)
        
      
        

          79
          
                @result
        
      
        

          
          
              ensure
        
      
        

          79
          
                remove_container
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            private
        
      
        

          
          
          
        
      
        

          1
          
            include FilesDelta
        
      
        

          1
          
            include TrafficLight
        
      
        

          
          
          
        
      
        

          1
          
            KB = 1024
        
      
        

          1
          
            MB = 1024 * KB
        
      
        

          1
          
            GB = 1024 * MB
        
      
        

          
          
          
        
      
        

          1
          
            SANDBOX_DIR = '/sandbox'  # where files are saved to in the container
        
      
        

          1
          
            UID = 41966               # sandbox user  - runs /sandbox/cyber-dojo.sh
        
      
        

          1
          
            GID = 51966               # sandbox group - runs /sandbox/cyber-dojo.sh
        
      
        

          1
          
            MAX_FILE_SIZE = 50 * KB   # of stdout, stderr, created, changed
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            def run(files, max_seconds)
        
      
        

          79
          
              command = main_docker_run_command
        
      
        

          79
          
              stdout,stderr,status,timed_out = nil,nil,nil,nil
        
      
        

          79
          
              r_stdin,  w_stdin  = IO.pipe
        
      
        

          79
          
              r_stdout, w_stdout = IO.pipe
        
      
        

          79
          
              r_stderr, w_stderr = IO.pipe
        
      
        

          79
          
              w_stdin.write(tgz(files))
        
      
        

          79
          
              w_stdin.close
        
      
        

          79
          
              pid = Process.spawn(command, {
        
      
        

          
          
                pgroup:true,     # become process leader
        
      
        

          
          
                    in:r_stdin,  # redirection
        
      
        

          
          
                   out:w_stdout, # redirection
        
      
        

          
          
                   err:w_stderr  # redirection
        
      
        

          
          
              })
        
      
        

          
          
              begin
        
      
        

          79
          
                Timeout::timeout(max_seconds) do
        
      
        

          79
          
                  _, ps = Process.waitpid2(pid)
        
      
        

          76
          
                  status = ps.exitstatus
        
      
        

          76
          
                  timed_out = killed?(status)
        
      
        

          
          
                end
        
      
        

          
          
              rescue Timeout::Error
        
      
        

          3
          
                Process_kill_group(pid)
        
      
        

          3
          
                Process_detach(pid)
        
      
        

          3
          
                status = KILLED_STATUS
        
      
        

          3
          
                timed_out = true
        
      
        

          
          
              ensure
        
      
        

          79
          
                w_stdout.close unless w_stdout.closed?
        
      
        

          79
          
                w_stderr.close unless w_stderr.closed?
        
      
        

          79
          
                stdout = packaged(read_max(r_stdout))
        
      
        

          79
          
                stderr = packaged(read_max(r_stderr))
        
      
        

          79
          
                r_stdout.close
        
      
        

          79
          
                r_stderr.close
        
      
        

          
          
              end
        
      
        

          79
          
              @result['run_cyber_dojo_sh'] = {
        
      
        

          
          
                stdout:stdout,
        
      
        

          
          
                stderr:stderr,
        
      
        

          
          
                status:status,
        
      
        

          
          
                timed_out:timed_out
        
      
        

          
          
              }
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            def tgz(files)
        
      
        

          79
          
              Gnu.zip(Tar::Writer.new(files).tar_file)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            def read_max(fd)
        
      
        

          158
          
              fd.read(MAX_FILE_SIZE + 1) || ''
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            def main_docker_run_command
        
      
        

          
          
              # Assumes a tgz of files on stdin. Untars this into the
        
      
        

          
          
              # /sandbox/ dir (which must exist [X]) inside the container
        
      
        

          
          
              # and runs /sandbox/cyber-dojo.sh
        
      
        

          
          
              #
        
      
        

          
          
              # [1] The uid/gid are for the user/group called sandbox [X].
        
      
        

          
          
              #     Untars files as this user to set their ownership.
        
      
        

          
          
              # [2] Don't use [docker exec --workdir] as that requires API version
        
      
        

          
          
              #     1.35 but CircleCI is currently using Docker Daemon API 1.32
        
      
        

          
          
              # [3] tar is installed [X].
        
      
        

          
          
              # [4] tar has the --touch option installed [X].
        
      
        

          
          
              #     (not true in a default Alpine container)
        
      
        

          
          
              #     --touch means 'dont extract file modified time'
        
      
        

          
          
              #     It relates to the files modification-date (stat %y).
        
      
        

          
          
              #     Without it the untarred files may all end up with the same
        
      
        

          
          
              #     modification date. With it, the untarred files have a
        
      
        

          
          
              #     proper date-time file-stamp in all supported OS's.
        
      
        

          
          
              # [5] tar date-time file-stamps have a granularity < 1 second [X].
        
      
        

          
          
              #     In a default Alpine container the date-time file-stamps
        
      
        

          
          
              #     have a granularity of one second; viz, the microseconds
        
      
        

          
          
              #     value is always zero.
        
      
        

          79
          
              <<~SHELL.strip
        
      
        

          
          
                docker exec                                     \
        
      
        

          
          
                  --interactive            `# piping stdin`     \
        
      
        

          
          
                  --user=#{UID}:#{GID}     `# [1]`              \
        
      
        

          
          
                  #{@container_name}                            \
        
      
        

          
          
                  bash -c                                       \
        
      
        

          
          
                    '                      `# open quote`       \
        
      
        

          
          
                    cd #{SANDBOX_DIR}      `# [2]`              \
        
      
        

          
          
                    &&                                          \
        
      
        

          
          
                    tar                    `# [3]`              \
        
      
        

          
          
                      --touch              `# [4][5]`           \
        
      
        

          
          
                      -zxf                 `# extract tgz file` \
        
      
        

          
          
                      -                    `# read from stdin`  \
        
      
        

          
          
                    &&                                          \
        
      
        

          
          
                    bash ./cyber-dojo.sh                        \
        
      
        

          
          
                    '                      `# close quote`
        
      
        

          
          
              SHELL
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            def text_file_changes(files)
        
      
        

          
          
              # Approval-style test-frameworks compare actual-text against
        
      
        

          
          
              # expected-text held inside a 'golden-master' file and, if the
        
      
        

          
          
              # comparison fails, generate a file holding the actual-text
        
      
        

          
          
              # ready for human inspection. cyber-dojo supports this by
        
      
        

          
          
              # tar-piping out all text files (generated inside the container)
        
      
        

          
          
              # under /sandbox after cyber-dojo.sh has run.
        
      
        

          
          
              #
        
      
        

          
          
              # [1] Extract /usr/local/bin/red_amber_green.rb if it exists.
        
      
        

          
          
              # [2] Ensure filenames are not read as tar command options.
        
      
        

          
          
              #     Eg -J... is a tar compression option.
        
      
        

          
          
              #     This option is not available on Ubuntu 16.04
        
      
        

          79
          
              rag_filename = SecureRandom.urlsafe_base64
        
      
        

          
          
              docker_tar_pipe_text_files_out =
        
      
        

          79
          
                <<~SHELL.strip
        
      
        

          
          
                docker exec                                       \
        
      
        

          
          
                  --user=#{UID}:#{GID}                            \
        
      
        

          
          
                  #{@container_name}                              \
        
      
        

          
          
                  bash -c                                         \
        
      
        

          
          
                    '                         `# open quote`      \
        
      
        

          
          
                    #{copy_rag(rag_filename)} `# [1]`;            \
        
      
        

          
          
                    #{ECHO_TRUNCATED_TEXTFILE_NAMES}              \
        
      
        

          
          
                    |                                             \
        
      
        

          
          
                    tar                                           \
        
      
        

          
          
                      -C                                          \
        
      
        

          
          
                      #{SANDBOX_DIR}                              \
        
      
        

          
          
                      -zcf                    `# create tgz file` \
        
      
        

          
          
                      -                       `# write to stdout` \
        
      
        

          
          
                      --verbatim-files-from   `# [2]`             \
        
      
        

          
          
                      -T                      `# using filenames` \
        
      
        

          
          
                      -                       `# from stdin`      \
        
      
        

          
          
                    '                         `# close quote`
        
      
        

          
          
                SHELL
        
      
        

          
          
              # A crippled container (eg fork-bomb) will likely
        
      
        

          
          
              # not be running causing the [docker exec] to fail.
        
      
        

          
          
              # Be careful if you switch to shell.assert() here.
        
      
        

          79
          
              stdout,stderr,status = shell.exec(docker_tar_pipe_text_files_out)
        
      
        

          79
          
              if status === 0
        
      
        

          71
          
                files_now = read_tar_file(Gnu.unzip(stdout))
        
      
        

          71
          
                rag_src = extract_rag(files_now, rag_filename)
        
      
        

          71
          
                created,deleted,changed = *files_delta(files, files_now)
        
      
        

          
          
              else
        
      
        

          8
          
                @result['diagnostic'] = { 'stderr' => stderr }
        
      
        

          8
          
                rag_src = nil
        
      
        

          8
          
                created,deleted,changed = {}, [], {}
        
      
        

          
          
              end
        
      
        

          79
          
              @result['rag_src'] = rag_src
        
      
        

          79
          
              @result['run_cyber_dojo_sh'].merge!({
        
      
        

          
          
                created:created,
        
      
        

          
          
                deleted:deleted,
        
      
        

          
          
                changed:changed
        
      
        

          
          
              })
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            def copy_rag(rag_filename)
        
      
        

          79
          
              rag_src = '/usr/local/bin/red_amber_green.rb'
        
      
        

          79
          
              rag_dst = "#{SANDBOX_DIR}/#{rag_filename}"
        
      
        

          
          
              # This command must not write anything to stdout/stderr
        
      
        

          
          
              # since it would be taken as a filename by tar's -T option.
        
      
        

          79
          
              "[ -f #{rag_src} ] && cp #{rag_src} #{rag_dst}"
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            def extract_rag(files_now, rag_filename)
        
      
        

          71
          
              rag_file = files_now.delete(rag_filename)
        
      
        

          71
          
              if rag_file.nil?
        
      
        

          
          
                nil
        
      
        

          
          
              else
        
      
        

          70
          
                rag_file['content']
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            def read_tar_file(tar_file)
        
      
        

          71
          
              reader = Tar::Reader.new(tar_file)
        
      
        

          71
          
              reader.files.each_with_object({}) do |(filename,content),memo|
        
      
        

          597
          
                memo[filename] = packaged(content)
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
            # o) Must not contain a single-quote [bash -c '...']
        
      
        

          
          
            # o) grep -q is --quiet
        
      
        

          
          
            # o) grep -v is --invert-match
        
      
        

          
          
            # o) Strip ./ from front of pathed filename in depathed()
        
      
        

          
          
            # o) The file utility must be installed [X].
        
      
        

          
          
            #    However, it incorrectly reports size==0,1 as binary
        
      
        

          
          
            #    which is impossible. No executable binary can be that small.
        
      
        

          
          
            # o) truncates text files to MAX_FILE_SIZE+1
        
      
        

          
          
            #    This is so truncated?() can detect the truncation.
        
      
        

          
          
            #    The truncate utility must be installed [X].
        
      
        

          
          
          
        
      
        

          
          
            ECHO_TRUNCATED_TEXTFILE_NAMES =
        
      
        

          1
          
              <<~SHELL.strip
        
      
        

          
          
                truncate_file() \
        
      
        

          
          
                { \
        
      
        

          
          
                  if [ $(stat -c%s "${1}") -gt #{MAX_FILE_SIZE} ]; then \
        
      
        

          
          
                    truncate -s #{MAX_FILE_SIZE+1} "${1}"; \
        
      
        

          
          
                  fi; \
        
      
        

          
          
                }; \
        
      
        

          
          
                is_text_file() \
        
      
        

          
          
                { \
        
      
        

          
          
                  if file --mime-encoding ${1} | grep -qv "${1}:\\sbinary"; then \
        
      
        

          
          
                    truncate_file "${1}"; \
        
      
        

          
          
                    true; \
        
      
        

          
          
                  elif [ $(stat -c%s "${1}") -lt 2 ]; then \
        
      
        

          
          
                    true; \
        
      
        

          
          
                  else \
        
      
        

          
          
                    false; \
        
      
        

          
          
                  fi; \
        
      
        

          
          
                }; \
        
      
        

          
          
                depathed() \
        
      
        

          
          
                { \
        
      
        

          
          
                  echo "${1:2}"; \
        
      
        

          
          
                }; \
        
      
        

          
          
                export -f truncate_file; \
        
      
        

          
          
                export -f is_text_file; \
        
      
        

          
          
                export -f depathed; \
        
      
        

          
          
                (cd #{SANDBOX_DIR} && find . -type f -exec \
        
      
        

          
          
                  bash -c "is_text_file {} && depathed {}" \\;)
        
      
        

          
          
              SHELL
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
            # container
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            def create_container(image_name, id, max_seconds)
        
      
        

          80
          
              @container_name = ['cyber_dojo_runner', id, random_id].join('_')
        
      
        

          
          
              docker_run = [
        
      
        

          80
          
                'docker run',
        
      
        

          
          
                  "--name=#{@container_name}",
        
      
        

          
          
                  docker_run_options(image_name, id),
        
      
        

          
          
                  image_name,
        
      
        

          
          
                    "bash -c 'sleep #{max_seconds}'"
        
      
        

          
          
              ].join(SPACE)
        
      
        

          
          
              # The --detach run-option means this assert will not catch
        
      
        

          
          
              # some errors. For example, if the container has no bash [X].
        
      
        

          80
          
              shell.assert(docker_run)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            def remove_container
        
      
        

          
          
              # Backgrounded for a small speed-up.
        
      
        

          79
          
              shell.exec("docker rm #{@container_name} --force &")
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            def random_id
        
      
        

          
          
              # Add a random-id to the container name. A container-name
        
      
        

          
          
              # based on _only_ the id will fail when a container with
        
      
        

          
          
              # that id exists and is alive. Note that remove_container()
        
      
        

          
          
              # backgrounds the [docker rm].
        
      
        

          80
          
              HEX_DIGITS.shuffle[0,8].join
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            HEX_DIGITS = [*('a'..'z'),*('A'..'Z'),*('0'..'9')]
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            def docker_run_options(image_name, id)
        
      
        

          
          
              # [1] For clang/clang++'s -fsanitize=address
        
      
        

          
          
              # [2] Makes container removal much faster
        
      
        

          
          
              <<~SHELL.strip
        
      
        

          80
          
                #{env_vars(image_name, id)}                      \
        
      
        

          
          
                #{TMP_FS_SANDBOX_DIR}                            \
        
      
        

          
          
                #{TMP_FS_TMP_DIR}                                \
        
      
        

          
          
                #{ulimits(image_name)}                           \
        
      
        

          
          
                --cap-add=SYS_PTRACE      `# [1]`                \
        
      
        

          
          
                --detach                  `# later docker execs` \
        
      
        

          
          
                --init                    `# pid-1 process [2]`  \
        
      
        

          
          
                --rm                      `# auto rm on exit`    \
        
      
        

          
          
                --user=#{UID}:#{GID}      `# not root`
        
      
        

          
          
              SHELL
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            def env_vars(image_name, id)
        
      
        

          
          
              [
        
      
        

          80
          
                env_var('IMAGE_NAME', image_name),
        
      
        

          
          
                env_var('ID',         id),
        
      
        

          
          
                env_var('SANDBOX',    SANDBOX_DIR)
        
      
        

          
          
              ].join(SPACE)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            def env_var(name, value)
        
      
        

          
          
              # Note: value must not contain a single-quote
        
      
        

          240
          
              "--env CYBER_DOJO_#{name}='#{value}'"
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          
          
            TMP_FS_SANDBOX_DIR =
        
      
        

          1
          
              "--tmpfs #{SANDBOX_DIR}:" +
        
      
        

          
          
              'exec,' +       # [1]
        
      
        

          
          
              'size=50M,' +   # [2]
        
      
        

          
          
              "uid=#{UID}," + # [3]
        
      
        

          
          
              "gid=#{GID}"    # [3]
        
      
        

          
          
              # Making the sandbox dir a tmpfs should improve speed.
        
      
        

          
          
              # By default, tmp-fs's are setup as secure mountpoints.
        
      
        

          
          
              # If you use only '--tmpfs #{SANDBOX_DIR}'
        
      
        

          
          
              # then a [cat /etc/mtab] will reveal something like
        
      
        

          
          
              # "tmpfs /sandbox tmpfs rw,nosuid,nodev,noexec,relatime,size=10240k 0 0"
        
      
        

          
          
              #   o) rw = Mount the filesystem read-write.
        
      
        

          
          
              #   o) nosuid = Do not allow set-user-identifier or
        
      
        

          
          
              #      set-group-identifier bits to take effect.
        
      
        

          
          
              #   o) nodev = Do not interpret character or block special devices.
        
      
        

          
          
              #   o) noexec = Do not allow direct execution of any binaries.
        
      
        

          
          
              #   o) relatime = Update inode access times relative to modify/change time.
        
      
        

          
          
              #   So...
        
      
        

          
          
              #     [1] set exec to make binaries and scripts executable.
        
      
        

          
          
              #     [2] limit size of tmp-fs.
        
      
        

          
          
              #     [3] set ownership.
        
      
        

          
          
          
        
      
        

          1
          
            TMP_FS_TMP_DIR = '--tmpfs /tmp:exec,size=50M,mode=1777' # Set /tmp sticky-bit
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            def ulimits(image_name)
        
      
        

          
          
              # There is no cpu-ulimit... a cpu-ulimit of 10
        
      
        

          
          
              # seconds could kill a container after only 5
        
      
        

          
          
              # seconds... The cpu-ulimit assumes one core.
        
      
        

          
          
              # The host system running the docker container
        
      
        

          
          
              # can have multiple cores or use hyperthreading.
        
      
        

          
          
              # So a piece of code running on 2 cores, both 100%
        
      
        

          
          
              # utilized could be killed after 5 seconds.
        
      
        

          
          
              options = [
        
      
        

          80
          
                ulimit('core'  ,   0   ),           # core file size
        
      
        

          
          
                ulimit('fsize' ,  16*MB),           # file size
        
      
        

          
          
                ulimit('locks' , 128   ),           # number of file locks
        
      
        

          
          
                ulimit('nofile', 256   ),           # number of files
        
      
        

          
          
                ulimit('nproc' , 128   ),           # number of processes
        
      
        

          
          
                ulimit('stack' ,   8*MB),           # stack size
        
      
        

          
          
                '--memory=512m',                    # max 512MB ram
        
      
        

          
          
                '--net=none',                       # no network
        
      
        

          
          
                '--pids-limit=128',                 # no fork bombs
        
      
        

          
          
                '--security-opt=no-new-privileges', # no escalation
        
      
        

          
          
              ]
        
      
        

          80
          
              unless clang?(image_name)
        
      
        

          
          
                # [ulimit data] prevents clang's -fsanitize=address option.
        
      
        

          78
          
                options << ulimit('data', 4*GB)     # data segment size
        
      
        

          
          
              end
        
      
        

          80
          
              options.join(SPACE)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            def ulimit(name, limit)
        
      
        

          558
          
              "--ulimit #{name}=#{limit}"
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            def clang?(image_name)
        
      
        

          80
          
              image_name.start_with?('cyberdojofoundation/clang')
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
            # process helpers
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            def Process_kill_group(pid)
        
      
        

          
          
              # The [docker run] process running on the _host_ is
        
      
        

          
          
              # killed by this Process.kill. This does _not_ kill the
        
      
        

          
          
              # cyber-dojo.sh process running _inside_ the docker
        
      
        

          
          
              # container. The container is killed by remove_container()
        
      
        

          
          
              # with a fall-back via [docker run]'s --rm option.
        
      
        

          3
          
              Process.kill(-KILL_SIGNAL, pid) # -ve means kill process-group
        
      
        

          
          
            rescue Errno::ESRCH
        
      
        

          
          
              # There may no longer be a process at pid (timeout race).
        
      
        

          
          
              # If not, you get an exception Errno::ESRCH: No such process
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            def Process_detach(pid)
        
      
        

          
          
              # Prevents zombie child-process. Don't wait for detach status.
        
      
        

          3
          
              Process.detach(pid)
        
      
        

          
          
              # There may no longer be a process at pid (timeout race).
        
      
        

          
          
              # If not, you don't get an exception.
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            def killed?(status)
        
      
        

          76
          
              status === KILLED_STATUS
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            KILL_SIGNAL = 9
        
      
        

          
          
          
        
      
        

          1
          
            KILLED_STATUS = 128 + KILL_SIGNAL
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
            # file content helpers
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            def packaged(raw_content)
        
      
        

          755
          
              content = Utf8.clean(raw_content)
        
      
        

          
          
              {
        
      
        

          755
          
                  'content' => truncated(content),
        
      
        

          
          
                'truncated' => truncated?(content)
        
      
        

          
          
              }
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def truncated(content)
        
      
        

          755
          
              content[0...MAX_FILE_SIZE]
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def truncated?(content)
        
      
        

          755
          
              content.size > MAX_FILE_SIZE
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
            # externals
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            def shell
        
      
        

          238
          
              @externals.shell
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            SPACE = ' '
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          
          
          # frozen_string_literal: true
        
      
        

          1
          
          require_relative 'shell_assert_error'
        
      
        

          
          
          
        
      
        

          1
          
          class Shell
        
      
        

          
          
          
        
      
        

          1
          
            def initialize(externals)
        
      
        

          86
          
              @externals = externals
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            def exec(command)
        
      
        

          162
          
              bash_run(command)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            def assert(command)
        
      
        

          99
          
              stdout,stderr,status = bash_run(command)
        
      
        

          97
          
              unless success?(status)
        
      
        

          1
          
                args = [command,stdout,stderr,status]
        
      
        

          1
          
                raise ShellAssertError.new(*args)
        
      
        

          
          
              end
        
      
        

          96
          
              stdout
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            private
        
      
        

          
          
          
        
      
        

          1
          
            SUCCESS = 0
        
      
        

          
          
          
        
      
        

          1
          
            def success?(status)
        
      
        

          355
          
              status === SUCCESS
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def bash_run(command)
        
      
        

          261
          
              stdout,stderr,status = bash.run(command)
        
      
        

          258
          
              unless success?(status) && ignore?(stderr)
        
      
        

          11
          
                args = [command,stdout,stderr,status]
        
      
        

          11
          
                log << ShellAssertError.new(*args).message
        
      
        

          
          
              end
        
      
        

          258
          
              [stdout, stderr, status]
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            def ignore?(stderr)
        
      
        

          248
          
              stderr.empty? || known_circle_ci_warning?(stderr)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            KNOWN_CIRCLE_CI_WARNING =
        
      
        

          1
          
              "WARNING: Your kernel does not support swap limit capabilities or the cgroup is not mounted. " +
        
      
        

          
          
              "Memory limited without swap."
        
      
        

          
          
          
        
      
        

          1
          
            def known_circle_ci_warning?(stderr)
        
      
        

          2
          
              on_circle_ci? && stderr.start_with?(KNOWN_CIRCLE_CI_WARNING)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def on_circle_ci?
        
      
        

          2
          
              ENV.include?('CIRCLECI')
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            def bash
        
      
        

          261
          
              @externals.bash
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def log
        
      
        

          11
          
              @externals.log
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          
          
          # frozen_string_literal: true
        
      
        

          1
          
          require_relative 'utf8_clean'
        
      
        

          1
          
          require 'json'
        
      
        

          
          
          
        
      
        

          1
          
          class ShellAssertError < StandardError
        
      
        

          
          
          
        
      
        

          1
          
            def initialize(command, stdout, stderr, status)
        
      
        

          15
          
              super(JSON.pretty_generate({
        
      
        

          
          
                'command' => Utf8.clean(command),
        
      
        

          
          
                'stdout'  => Utf8.clean(stdout),
        
      
        

          
          
                'stderr'  => Utf8.clean(stderr),
        
      
        

          
          
                'status'  => status
        
      
        

          
          
              }))
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          
          
          # frozen_string_literal: true
        
      
        

          1
          
          require 'rubygems/package'  # Gem::Package::TarReader
        
      
        

          1
          
          require 'stringio'
        
      
        

          
          
          
        
      
        

          1
          
          module Tar
        
      
        

          
          
          
        
      
        

          1
          
            class Reader
        
      
        

          
          
          
        
      
        

          1
          
              def initialize(tar_file)
        
      
        

          73
          
                io = StringIO.new(tar_file, 'r+t')
        
      
        

          73
          
                @reader = Gem::Package::TarReader.new(io)
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          1
          
              def files
        
      
        

          
          
                # empty files are coming back as nil
        
      
        

          673
          
                @reader.map { |e| [e.full_name, e.read || ''] }.to_h
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          require 'rubygems/package'  # Gem::Package::TarWriter
        
      
        

          1
          
          require 'stringio'
        
      
        

          
          
          
        
      
        

          1
          
          module Tar
        
      
        

          
          
          
        
      
        

          1
          
            class Writer
        
      
        

          
          
          
        
      
        

          1
          
              def initialize(files = {})
        
      
        

          82
          
                @tar_file = StringIO.new('')
        
      
        

          82
          
                @writer = Gem::Package::TarWriter.new(@tar_file)
        
      
        

          82
          
                files.each do |filename, content|
        
      
        

          261
          
                  write(filename, content)
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          1
          
              def write(filename, content)
        
      
        

          265
          
                size = content.bytesize
        
      
        

          265
          
                @writer.add_file_simple(filename, 0o644, size) do |fd|
        
      
        

          265
          
                  fd.write(content)
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          1
          
              def tar_file
        
      
        

          81
          
                @tar_file.string
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          
          
          # frozen_string_literal: true
        
      
        

          1
          
          require_relative 'empty'
        
      
        

          
          
          
        
      
        

          1
          
          module TrafficLight
        
      
        

          
          
          
        
      
        

          1
          
            def traffic_light(image_name, id)
        
      
        

          79
          
              if @result['run_cyber_dojo_sh'][:timed_out]
        
      
        

          3
          
                return
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          76
          
              rag_src = @result['rag_src']
        
      
        

          76
          
              if rag_src.nil?
        
      
        

          8
          
                @result.merge!({ 'colour' => 'faulty' })
        
      
        

          8
          
                @result['diagnostic'] ||= {}
        
      
        

          8
          
                @result['diagnostic'].merge!({
        
      
        

          
          
                  'image_name' => image_name,
        
      
        

          
          
                  'id' => id,
        
      
        

          
          
                  'info' => "no /usr/local/bin/red_amber_green.rb in #{image_name}"
        
      
        

          
          
                })
        
      
        

          8
          
                return
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              begin
        
      
        

          68
          
                rag_lambda = Empty.binding.eval(rag_src)
        
      
        

          
          
              rescue Exception => error
        
      
        

          3
          
                @result.merge!({ 'colour' => 'faulty' })
        
      
        

          3
          
                @result['diagnostic'] ||= {}
        
      
        

          3
          
                @result['diagnostic'].merge!({
        
      
        

          
          
                  'image_name' => image_name,
        
      
        

          
          
                  'id' => id,
        
      
        

          
          
                  'info' => 'eval(rag_lambda) raised an exception',
        
      
        

          
          
                  'name' => error.class.name,
        
      
        

          
          
                  'message' => error.message.split("\n"),
        
      
        

          
          
                  'rag_lambda' => rag_src.split("\n")
        
      
        

          
          
                })
        
      
        

          3
          
                return
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              begin
        
      
        

          65
          
                stdout = @result['run_cyber_dojo_sh'][:stdout]['content']
        
      
        

          65
          
                stderr = @result['run_cyber_dojo_sh'][:stderr]['content']
        
      
        

          65
          
                status = @result['run_cyber_dojo_sh'][:status]
        
      
        

          65
          
                colour = rag_lambda.call(stdout, stderr, status).to_s
        
      
        

          
          
              rescue => error
        
      
        

          3
          
                @result.merge!({ 'colour' => 'faulty' })
        
      
        

          3
          
                @result['diagnostic'] ||= {}
        
      
        

          3
          
                @result['diagnostic'].merge!({
        
      
        

          
          
                  'image_name' => image_name,
        
      
        

          
          
                  'id' => id,
        
      
        

          
          
                  'info' => 'rag_lambda.call raised an exception',
        
      
        

          
          
                  'name' => error.class.name,
        
      
        

          
          
                  'message' => error.message.split("\n"),
        
      
        

          
          
                  'rag_lambda' => rag_src.split("\n")
        
      
        

          
          
                })
        
      
        

          3
          
                return
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          62
          
              unless colour === 'red' || colour === 'amber' || colour === 'green'
        
      
        

          1
          
                @result.merge!({ 'colour' => 'faulty' })
        
      
        

          1
          
                @result['diagnostic'] ||= {}
        
      
        

          1
          
                @result['diagnostic'].merge!({
        
      
        

          
          
                  'image_name' => image_name,
        
      
        

          
          
                  'id' => id,
        
      
        

          
          
                  'info' => "rag_lambda.call is '#{colour}' which is not 'red'|'amber'|'green'",
        
      
        

          
          
                  'rag_lambda' => rag_src.split("\n")
        
      
        

          
          
                })
        
      
        

          1
          
                return
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          61
          
              @result.merge!({ 'colour' => colour })
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          
          
          # frozen_string_literal: true
        
      
        

          1
          
          module Utf8
        
      
        

          
          
          
        
      
        

          1
          
            def self.clean(s)
        
      
        

          
          
              # force an encoding change
        
      
        

          
          
              # if encoding is already utf-8 then encoding
        
      
        

          
          
              # to utf-8 is a no-op and invalid byte sequences
        
      
        

          
          
              # are not detected.
        
      
        

          801
          
              s = s.encode('UTF-16', 'UTF-8', :invalid => :replace, :replace => '')
        
      
        

          801
          
              s = s.encode('UTF-8', 'UTF-16')
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
        

          
          
          
        
      
        

          
          
          # http://robots.thoughtbot.com/fight-back-utf-8-invalid-byte-sequences
        
      
    
  

    

      
        

          1
          
          require 'minitest/autorun'
        
      
        

          
          
          
        
      
        

          1
          
          def require_src(required)
        
      
        

          10
          
            require_relative "../app/src/#{required}"
        
      
        

          
          
          end
        
      
        

          
          
          
        
      
        

          1
          
          class Id58TestBase < MiniTest::Test
        
      
        

          
          
          
        
      
        

          1
          
            def initialize(arg)
        
      
        

          112
          
              @_id58 = nil
        
      
        

          112
          
              @_name58 = nil
        
      
        

          112
          
              super
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            @@args = (ARGV.sort.uniq - ['--']) # eg 2m4
        
      
        

          1
          
            @@seen_ids = []
        
      
        

          1
          
            @@timings = {}
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            def self.define_test(os, display_name, id58_suffix, *lines, &test_block)
        
      
        

          112
          
              src = test_block.source_location
        
      
        

          112
          
              src_file = File.basename(src[0])
        
      
        

          112
          
              src_line = src[1].to_s
        
      
        

          112
          
              id58 = checked_id58(id58_suffix, lines)
        
      
        

          112
          
              if @@args === [] || @@args.any?{ |arg| id58.include?(arg) }
        
      
        

          112
          
                name58 = lines.join(space = ' ')
        
      
        

          112
          
                execute_around = lambda {
        
      
        

          112
          
                  ENV['ID58'] = id58
        
      
        

          112
          
                  @_os = os
        
      
        

          112
          
                  @_display_name = display_name
        
      
        

          112
          
                  @_id58 = id58
        
      
        

          112
          
                  @_name58 = name58
        
      
        

          112
          
                  id58_setup
        
      
        

          
          
                  begin
        
      
        

          112
          
                    t1 = Time.now
        
      
        

          112
          
                    self.instance_eval(&test_block)
        
      
        

          112
          
                    t2 = Time.now
        
      
        

          112
          
                    @@timings[id58+':'+src_file+':'+src_line+':'+name58] = (t2 - t1)
        
      
        

          
          
                  ensure
        
      
        

          112
          
                    puts $!.message unless $!.nil?
        
      
        

          112
          
                    id58_teardown
        
      
        

          
          
                  end
        
      
        

          
          
                }
        
      
        

          112
          
                name = "id58 '#{id58_suffix}',\n'#{name58}'"
        
      
        

          112
          
                define_method("test_\n#{name}".to_sym, &execute_around)
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          
          skipped
            # :nocov:
        
      
        

          
          skipped
            ObjectSpace.define_finalizer(self, proc {
        
      
        

          
          skipped
              slow = @@timings.select{ |_name,secs| secs > 0.000 }
        
      
        

          
          skipped
              sorted = slow.sort_by{ |name,secs| -secs }.to_h
        
      
        

          
          skipped
              size = sorted.size < 5 ? sorted.size : 5
        
      
        

          
          skipped
              puts
        
      
        

          
          skipped
              puts "Slowest #{size} tests are..." if size != 0
        
      
        

          
          skipped
              sorted.each_with_index { |(name,secs),index|
        
      
        

          
          skipped
                puts "%3.4f - %-72s" % [secs,name]
        
      
        

          
          skipped
                break if index === size
        
      
        

          
          skipped
              }
        
      
        

          
          skipped
              puts
        
      
        

          
          skipped
            })
        
      
        

          
          skipped
            # :nocov:
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          
          
            ID58_ALPHABET = %w{
        
      
        

          1
          
              0 1 2 3 4 5 6 7 8 9
        
      
        

          
          
              A B C D E F G H   J K L M N   P Q R S T U V W X Y Z
        
      
        

          
          
              a b c d e f g h   j k l m n   p q r s t u v w x y z
        
      
        

          
          
            }.join.freeze
        
      
        

          
          
          
        
      
        

          1
          
            def self.id58?(s)
        
      
        

          224
          
              s.is_a?(String) &&
        
      
        

          716
          
                s.chars.all?{ |ch| ID58_ALPHABET.include?(ch) }
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def self.checked_id58(id58_suffix, lines)
        
      
        

          112
          
              method = 'def self.id58_prefix'
        
      
        

          112
          
              pointer = ' ' * method.index('.') + '!'
        
      
        

          112
          
              pointee = (['',pointer,method,'','']).join("\n")
        
      
        

          112
          
              pointer.prepend("\n\n")
        
      
        

          112
          
              raise "#{pointer}missing#{pointee}" unless respond_to?(:id58_prefix)
        
      
        

          112
          
              raise "#{pointer}empty#{pointee}" if id58_prefix === ''
        
      
        

          112
          
              raise "#{pointer}not id58#{pointee}" unless id58?(id58_prefix)
        
      
        

          
          
          
        
      
        

          112
          
              method = "test '#{id58_suffix}',"
        
      
        

          112
          
              pointer = ' ' * method.index("'") + '!'
        
      
        

          112
          
              proposition = lines.join(space = ' ')
        
      
        

          112
          
              pointee = ['',pointer,method,"'#{proposition}'",'',''].join("\n")
        
      
        

          112
          
              id58 = id58_prefix + id58_suffix
        
      
        

          112
          
              pointer.prepend("\n\n")
        
      
        

          112
          
              raise "#{pointer}empty#{pointee}" if id58_suffix === ''
        
      
        

          112
          
              raise "#{pointer}not id58#{pointee}" unless id58?(id58_suffix)
        
      
        

          112
          
              raise "#{pointer}duplicate#{pointee}" if @@seen_ids.include?(id58)
        
      
        

          112
          
              raise "#{pointer}overlap#{pointee}" if id58_prefix[-2..-1] === id58_suffix[0..1]
        
      
        

          112
          
              @@seen_ids << id58
        
      
        

          112
          
              id58
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            def id58_setup
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def id58_teardown
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            def os
        
      
        

          6
          
              @_os
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def display_name
        
      
        

          68
          
              @_display_name
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def id58
        
      
        

          105
          
              @_id58
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          skipped
            # :nocov:
        
      
        

          
          skipped
            def name58
        
      
        

          
          skipped
              @_name58
        
      
        

          
          skipped
            end
        
      
        

          
          skipped
            # :nocov:
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          
          
          
        
      
        

          1
          
          class BashStub
        
      
        

          
          
          
        
      
        

          1
          
            def initialize
        
      
        

          6
          
              test_id = ENV['ID58']
        
      
        

          6
          
              @filename = Dir.tmpdir + '/cyber_dojo_bash_stub_' + test_id + '.json'
        
      
        

          6
          
              unless File.file?(filename)
        
      
        

          6
          
                write([])
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            def teardown
        
      
        

          4
          
              unless uncaught_exception?
        
      
        

          3
          
                stubs = read
        
      
        

          3
          
                pretty = JSON.pretty_generate(stubs)
        
      
        

          3
          
                unless stubs === []
        
      
        

          1
          
                  raise "#{filename}: uncalled stubs(#{pretty})"
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            def stub_run(command, stdout, stderr, status)
        
      
        

          4
          
              stubs = read
        
      
        

          
          
              stub = {
        
      
        

          4
          
                command:command,
        
      
        

          
          
                 stdout:stdout,
        
      
        

          
          
                 stderr:stderr,
        
      
        

          
          
                 status:status
        
      
        

          
          
              }
        
      
        

          4
          
              write(stubs << stub)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            def run(command)
        
      
        

          3
          
              stubs = read
        
      
        

          3
          
              stub = stubs.shift
        
      
        

          3
          
              write(stubs)
        
      
        

          3
          
              if stub.nil?
        
      
        

          1
          
                raise [
        
      
        

          
          
                  self.class.name,
        
      
        

          
          
                  "run(command) - no stub",
        
      
        

          
          
                  "actual-command: #{command}",
        
      
        

          
          
                ].join("\n") + "\n"
        
      
        

          
          
              end
        
      
        

          2
          
              unless command === stub['command']
        
      
        

          1
          
                raise [
        
      
        

          
          
                  self.class.name,
        
      
        

          
          
                  "run(command) - does not match stub",
        
      
        

          
          
                  "actual-command: #{command}",
        
      
        

          
          
                  "stubbed-command: #{stub['command']}"
        
      
        

          
          
                ].join("\n") + "\n"
        
      
        

          
          
              end
        
      
        

          1
          
              [stub['stdout'], stub['stderr'], stub['status']]
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            private # = = = = = = = = = = = = = = = = = =
        
      
        

          
          
          
        
      
        

          1
          
            def read
        
      
        

          10
          
              JSON.parse(IO.read(filename))
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def write(stubs)
        
      
        

          13
          
              IO.write(filename, JSON.unparse(stubs))
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def filename
        
      
        

          30
          
              @filename
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def uncaught_exception?
        
      
        

          4
          
              $!
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          
          
          
        
      
        

          1
          
          class BashStubRaiser
        
      
        

          
          
          
        
      
        

          1
          
            def initialize(message)
        
      
        

          1
          
              @message = message
        
      
        

          1
          
              @fired_count = 0
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def fired_once?
        
      
        

          1
          
              @fired_count === 1
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def run(command)
        
      
        

          1
          
              @fired_count += 1
        
      
        

          1
          
              raise ArgumentError.new(@message)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          require 'open3'
        
      
        

          
          
          
        
      
        

          1
          
          class BashStubTarPipeOut
        
      
        

          
          
          
        
      
        

          1
          
            def initialize(content)
        
      
        

          3
          
              @content = content
        
      
        

          3
          
              @fired_count = 0
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def fired_once?
        
      
        

          3
          
              @fired_count === 1
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def run(command)
        
      
        

          9
          
              if command.include?('is_text_file')
        
      
        

          3
          
                @fired_count += 1
        
      
        

          3
          
                return stdout=@content,stderr='',status=1
        
      
        

          
          
              else
        
      
        

          6
          
                stdout,stderr,r = Open3.capture3(command)
        
      
        

          6
          
                [ stdout, stderr, r.exitstatus ]
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          
          
          # frozen_string_literal: true
        
      
        

          1
          
          require_relative 'test_base'
        
      
        

          1
          
          require_relative 'bash_stub'
        
      
        

          
          
          
        
      
        

          1
          
          class BashStubTest < TestBase
        
      
        

          
          
          
        
      
        

          1
          
            def self.id58_prefix
        
      
        

          24
          
              'F03'
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def id58_setup
        
      
        

          6
          
              @bash = BashStub.new
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            attr_reader :bash
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            test '4A5',
        
      
        

          
          
            %w( teardown does not raise
        
      
        

          
          
                when no run()s are stubbed
        
      
        

          
          
                and no run()s are made
        
      
        

          
          
            ) do
        
      
        

          1
          
              bash.teardown
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            test '652',
        
      
        

          
          
            %w( run() raises when run() is not stubbed
        
      
        

          
          
            ) do
        
      
        

          2
          
              assert_raises { bash.run(pwd) }
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            test '181',
        
      
        

          
          
            %w( run() raises when run() is stubbed but for a different command
        
      
        

          
          
            ) do
        
      
        

          1
          
              bash.stub_run(pwd, wd, stderr='', success)
        
      
        

          2
          
              assert_raises { bash.run(not_pwd = "cd #{wd}") }
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            test 'B4E',
        
      
        

          
          
            %w( teardown does not raise
        
      
        

          
          
                when one run() is stubbed
        
      
        

          
          
                and a matching run() is made
        
      
        

          
          
            ) do
        
      
        

          1
          
              bash.stub_run(pwd, wd, stderr='', success)
        
      
        

          1
          
              stdout,stderr,status = bash.run('pwd')
        
      
        

          1
          
              assert_equal wd, stdout
        
      
        

          1
          
              assert_equal '', stderr
        
      
        

          1
          
              assert_equal success, status
        
      
        

          1
          
              bash.teardown
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            test 'D0C',
        
      
        

          
          
            %w( teardown raises
        
      
        

          
          
                when a run() is stubbed
        
      
        

          
          
                and no run() is made
        
      
        

          
          
            ) do
        
      
        

          1
          
              bash.stub_run(pwd, wd, stderr='', success)
        
      
        

          2
          
              assert_raises { bash.teardown }
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            test '470',
        
      
        

          
          
            %w( teardown does not raise
        
      
        

          
          
                when there is an uncaught exception
        
      
        

          
          
            ) do
        
      
        

          1
          
              bash.stub_run(pwd, wd, stderr='', success)
        
      
        

          1
          
              error = assert_raises {
        
      
        

          
          
                begin
        
      
        

          1
          
                  raise 'forced'
        
      
        

          
          
                ensure
        
      
        

          1
          
                  bash.teardown
        
      
        

          
          
                end
        
      
        

          
          
              }
        
      
        

          1
          
              assert_equal 'forced', error.message
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            private # = = = = = = = = = = = = = = =
        
      
        

          
          
          
        
      
        

          1
          
            def pwd
        
      
        

          5
          
              'pwd'
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def wd
        
      
        

          6
          
              '/Users/jonjagger/repos/web'
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def success
        
      
        

          5
          
              0
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          
          
          # frozen_string_literal: true
        
      
        

          1
          
          require_relative 'test_base'
        
      
        

          
          
          
        
      
        

          1
          
          class AliveTest < TestBase
        
      
        

          
          
          
        
      
        

          1
          
            def self.id58_prefix
        
      
        

          4
          
              '6de'
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            test '190', %w(
        
      
        

          
          
            alive? is true, useful for k8s liveness probes
        
      
        

          
          
            ) do
        
      
        

          1
          
              assert alive?
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          
          
          # frozen_string_literal: true
        
      
        

          1
          
          require_relative 'test_base'
        
      
        

          
          
          
        
      
        

          1
          
          class BaselineSpeedTest < TestBase
        
      
        

          
          
          
        
      
        

          1
          
            def self.id58_prefix
        
      
        

          8
          
              '159'
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            multi_os_test '8A6',
        
      
        

          
          
            'baseline average speed is less than 1.7 secs' do
        
      
        

          2
          
              timings = []
        
      
        

          2
          
              (1..5).each do
        
      
        

          10
          
                started_at = Time.now
        
      
        

          10
          
                assert_cyber_dojo_sh('true')
        
      
        

          10
          
                stopped_at = Time.now
        
      
        

          10
          
                diff = Time.at(stopped_at - started_at).utc
        
      
        

          10
          
                secs = diff.strftime("%S").to_i
        
      
        

          10
          
                millisecs = diff.strftime("%L").to_i
        
      
        

          10
          
                timings << (secs * 1000 + millisecs)
        
      
        

          
          
              end
        
      
        

          2
          
              mean = timings.reduce(0, :+) / timings.size
        
      
        

          2
          
              assert mean < max=1700, "mean=#{mean}, max=#{max}"
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          
          
          # frozen_string_literal: true
        
      
        

          1
          
          require_relative 'test_base'
        
      
        

          
          
          
        
      
        

          1
          
          class BombRobustNessTest < TestBase
        
      
        

          
          
          
        
      
        

          1
          
            def self.id58_prefix
        
      
        

          24
          
              '1B5'
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            c_assert_test 'CD5',
        
      
        

          
          
            'fork-bomb does not run indefinitely' do
        
      
        

          1
          
              with_captured_log {
        
      
        

          1
          
                run_cyber_dojo_sh({
        
      
        

          
          
                  changed: { 'hiker.c' => C_FORK_BOMB },
        
      
        

          
          
                  max_seconds: 3
        
      
        

          
          
                })
        
      
        

          
          
              }
        
      
        

          1
          
              assert timed_out? ||
        
      
        

          
          
                printed?('fork()') ||
        
      
        

          
          
                  daemon_error? ||
        
      
        

          
          
                    no_such_container_error?, result
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            multi_os_test 'CD6',
        
      
        

          
          
            'shell fork-bomb does not run indefinitely' do
        
      
        

          2
          
              with_captured_log {
        
      
        

          2
          
                run_cyber_dojo_sh({
        
      
        

          
          
                  changed: { 'cyber-dojo.sh' => SHELL_FORK_BOMB },
        
      
        

          
          
                  max_seconds: 3
        
      
        

          
          
                })
        
      
        

          
          
              }
        
      
        

          
          
          
        
      
        

          2
          
              cant_fork = (os === :Alpine ? "can't fork" : 'Cannot fork')
        
      
        

          
          
              assert \
        
      
        

          2
          
                timed_out? ||
        
      
        

          
          
                  printed?(cant_fork) ||
        
      
        

          
          
                    printed?('bomb') ||
        
      
        

          
          
                      daemon_error? ||
        
      
        

          
          
                        no_such_container_error?, result
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            c_assert_test 'DB3',
        
      
        

          
          
            'file-handles quickly become exhausted' do
        
      
        

          1
          
              with_captured_log {
        
      
        

          1
          
                run_cyber_dojo_sh({
        
      
        

          
          
                  changed: { 'hiker.c' => FILE_HANDLE_BOMB },
        
      
        

          
          
                  max_seconds: 3
        
      
        

          
          
                })
        
      
        

          
          
              }
        
      
        

          1
          
              assert printed?('fopen() != NULL') ||
        
      
        

          
          
                daemon_error? ||
        
      
        

          
          
                  no_such_container_error?,  result
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            multi_os_test '62B',
        
      
        

          
          
            %w( a crippled container, eg from a fork-bomb, returns everything unchanged ) do
        
      
        

          2
          
              stub = BashStubTarPipeOut.new('fail')
        
      
        

          2
          
              @externals = Externals.new({ 'bash' => stub })
        
      
        

          4
          
              with_captured_log { run_cyber_dojo_sh }
        
      
        

          2
          
              assert stub.fired_once?
        
      
        

          2
          
              assert_created({})
        
      
        

          2
          
              assert_deleted([])
        
      
        

          2
          
              assert_changed({})
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            private # = = = = = = = = = = = = = = = = = = = = = =
        
      
        

          
          
          
        
      
        

          1
          
            C_FORK_BOMB = <<~'CODE'
        
      
        

          
          
              #include "hiker.h"
        
      
        

          
          
              #include <stdio.h>
        
      
        

          
          
              #include <unistd.h>
        
      
        

          
          
              int answer(void)
        
      
        

          
          
              {
        
      
        

          
          
                  for(;;)
        
      
        

          
          
                  {
        
      
        

          
          
                      int pid = fork();
        
      
        

          
          
                      fprintf(stdout, "fork() => %d\n", pid);
        
      
        

          
          
                      fflush(stdout);
        
      
        

          
          
                      if (pid == -1)
        
      
        

          
          
                          break;
        
      
        

          
          
                  }
        
      
        

          
          
                  return 6 * 7;
        
      
        

          
          
              }
        
      
        

          
          
            CODE
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            SHELL_FORK_BOMB = <<~CODE
        
      
        

          
          
              bomb()
        
      
        

          
          
              {
        
      
        

          
          
                echo "bomb"
        
      
        

          
          
                bomb | bomb &
        
      
        

          
          
              }
        
      
        

          
          
              bomb
        
      
        

          
          
            CODE
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            FILE_HANDLE_BOMB = <<~'CODE'
        
      
        

          
          
              #include "hiker.h"
        
      
        

          
          
              #include <stdio.h>
        
      
        

          
          
              int answer(void)
        
      
        

          
          
              {
        
      
        

          
          
                for (int i = 0;;i++)
        
      
        

          
          
                {
        
      
        

          
          
                  char filename[42];
        
      
        

          
          
                  sprintf(filename, "wibble%d.txt", i);
        
      
        

          
          
                  FILE * f = fopen(filename, "w");
        
      
        

          
          
                  if (f)
        
      
        

          
          
                    fprintf(stdout, "fopen() != NULL %s\n", filename);
        
      
        

          
          
                  else
        
      
        

          
          
                  {
        
      
        

          
          
                    fprintf(stdout, "fopen() == NULL %s\n", filename);
        
      
        

          
          
                    break;
        
      
        

          
          
                  }
        
      
        

          
          
                }
        
      
        

          
          
                return 6 * 7;
        
      
        

          
          
              }
        
      
        

          
          
            CODE
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          
          skipped
            # :nocov:
        
      
        

          
          skipped
            def printed?(text)
        
      
        

          
          skipped
              (stdout+stderr).lines.any? { |line| line.include?(text) }
        
      
        

          
          skipped
            end
        
      
        

          
          skipped
            # :nocov:
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          
          skipped
            # :nocov:
        
      
        

          
          skipped
            def daemon_error?
        
      
        

          
          skipped
              printed?('Error response from daemon: No such container') ||
        
      
        

          
          skipped
                regexp?(/Error response from daemon: Container .* is not running/)
        
      
        

          
          skipped
            end
        
      
        

          
          skipped
            # :nocov:
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          
          skipped
            # :nocov:
        
      
        

          
          skipped
            def regexp?(pattern)
        
      
        

          
          skipped
              (stdout+stderr) =~ pattern
        
      
        

          
          skipped
            end
        
      
        

          
          skipped
            # :nocov:
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          
          skipped
            # :nocov:
        
      
        

          
          skipped
            def no_such_container_error?
        
      
        

          
          skipped
              stderr.start_with?('Error: No such container: cyber_dojo_runner_')
        
      
        

          
          skipped
            end
        
      
        

          
          skipped
            # :nocov:
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          
          
          # frozen_string_literal: true
        
      
        

          1
          
          require_relative 'test_base'
        
      
        

          
          
          
        
      
        

          1
          
          class ClangSanitizeAddressTest < TestBase
        
      
        

          
          
          
        
      
        

          1
          
            def self.id58_prefix
        
      
        

          4
          
              'D28'
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            clang_assert_test '0BB',
        
      
        

          
          
            %w( clang sanitize address ) do
        
      
        

          1
          
              diagnostic = 'AddressSanitizer: heap-use-after-free on address'
        
      
        

          1
          
              run_cyber_dojo_sh
        
      
        

          1
          
              refute stderr.include?(diagnostic), stderr
        
      
        

          1
          
              run_cyber_dojo_sh( {
        
      
        

          
          
                changed:{ 'hiker.c' => leaks_memory }
        
      
        

          
          
              })
        
      
        

          1
          
              assert stderr.include?(diagnostic), stderr
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            def leaks_memory
        
      
        

          1
          
              <<~C_SOURCE
        
      
        

          
          
              #include "hiker.h"
        
      
        

          
          
              #include <stdlib.h>
        
      
        

          
          
          
        
      
        

          
          
              int answer(void)
        
      
        

          
          
              {
        
      
        

          
          
                  int * p = (int *)malloc(64);
        
      
        

          
          
                  p[0] = 6;
        
      
        

          
          
                  free(p);
        
      
        

          
          
                  return p[0] * 7;
        
      
        

          
          
              }
        
      
        

          
          
              C_SOURCE
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          
          
          # frozen_string_literal: true
        
      
        

          1
          
          require_relative 'test_base'
        
      
        

          
          
          
        
      
        

          1
          
          class ContainerPropertiesTest < TestBase
        
      
        

          
          
          
        
      
        

          1
          
            def self.id58_prefix
        
      
        

          12
          
              '3A8'
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            test 'D91', %w(
        
      
        

          
          
            requires bash, won't run in sh ) do
        
      
        

          1
          
              assert_equal '/bin/bash', assert_cyber_dojo_sh('printf ${SHELL}')
        
      
        

          1
          
              image_name = 'alpine:latest' # has sh but not bash
        
      
        

          1
          
              with_captured_log {
        
      
        

          1
          
                run_cyber_dojo_sh({image_name:image_name})
        
      
        

          
          
              }
        
      
        

          
          
          
        
      
        

          
          
              # main command is [docker run --detach IMAGE bash -c 'sleep 10']
        
      
        

          
          
              # The --detach means lack of bash is not a [docker run] error.
        
      
        

          
          
              # Subsequent failure behavior is dependent on non determinstic timings.
        
      
        

          1
          
              assert stdout === '' || stdout.start_with?('cannot exec in a stopped state:'), ":#{stdout}:"
        
      
        

          1
          
              assert stderr === '' || stderr.start_with?('Error response from daemon:'), ":#{stderr}:"
        
      
        

          
          
          
        
      
        

          1
          
              expected_info = "no /usr/local/bin/red_amber_green.rb in #{image_name}"
        
      
        

          1
          
              assert_equal 'faulty', colour
        
      
        

          1
          
              assert_equal image_name, diagnostic['image_name'], :image_name
        
      
        

          1
          
              assert_equal id, diagnostic['id'], :id
        
      
        

          1
          
              assert_equal expected_info, diagnostic['info'], :info
        
      
        

          1
          
              assert_nil diagnostic['message'], :message
        
      
        

          1
          
              assert_nil diagnostic['rag_lambda'], :rag_lambda
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            multi_os_test 'D98', %w( multiple container properties ) do
        
      
        

          
          
              cyber_dojo_sh = [
        
      
        

          2
          
                "#{stat_cmd}                       > #{sandbox_dir}/files.stat", # [1]
        
      
        

          
          
                "cat /proc/1/cmdline | cut -c1-9   > #{sandbox_dir}/proc.1", # [2]
        
      
        

          
          
                "cat /etc/passwd                   > #{sandbox_dir}/passwd",
        
      
        

          
          
                "getent group #{group}             > #{sandbox_dir}/group",
        
      
        

          
          
                "printf ${HOME}                    > #{sandbox_dir}/home.dir",
        
      
        

          
          
                "env                               > #{sandbox_dir}/env.vars",
        
      
        

          
          
                "stat --printf='%u' #{sandbox_dir} > #{sandbox_dir}/dir.stat.u",
        
      
        

          
          
                "stat --printf='%g' #{sandbox_dir} > #{sandbox_dir}/dir.stat.g",
        
      
        

          
          
                "stat --printf='%A' #{sandbox_dir} > #{sandbox_dir}/dir.stat.A",
        
      
        

          
          
                "ulimit -a                         > #{sandbox_dir}/ulimit.all"
        
      
        

          
          
              ].join(' && ')
        
      
        

          
          
          
        
      
        

          2
          
              assert_cyber_dojo_sh(cyber_dojo_sh)
        
      
        

          
          
          
        
      
        

          
          
              # [1] must be first so as not to see newly created files.
        
      
        

          
          
              # [2] On CircleCI, currently proc.1 is...  '/dev/init' + 0.chr + '--'
        
      
        

          
          
              # Yes, there is an embedded nul-character.
        
      
        

          
          
              # Depending on the version of docker you are using you may get
        
      
        

          
          
              # '/sbin/docker-init' instead of '/dev/init'
        
      
        

          
          
              # Either way, the embedded nul-character causes text_file_changes()
        
      
        

          
          
              # in runner.rb to see proc.1 as a binary file. Hence only the first
        
      
        

          
          
              # nine characters of proc/1/cmdline are saved, and proc.1 is seen
        
      
        

          
          
              # as a text file.
        
      
        

          2
          
              proc1 = created_file('proc.1')
        
      
        

          2
          
              expected_1 = '/dev/init'
        
      
        

          2
          
              expected_2 = '/sbin/docker-init'[0...expected_1.size]
        
      
        

          6
          
              assert [expected_1,expected_2].any?{|s|proc1.start_with?(s)}, proc1
        
      
        

          
          
          
        
      
        

          2
          
              etc_passwd = created_file('passwd')
        
      
        

          2
          
              etc_passwd_line = "sandbox:x:#{uid}:#{gid}:"
        
      
        

          50
          
              assert etc_passwd.lines.detect{|line| line.start_with?(etc_passwd_line)}, etc_passwd
        
      
        

          
          
          
        
      
        

          2
          
              fields = created_file('group').split(':')  # sandbox:x:51966
        
      
        

          2
          
              assert_equal group, fields[0], :group_name
        
      
        

          2
          
              assert_equal   gid, fields[2].to_i, :group_gid
        
      
        

          
          
          
        
      
        

          2
          
              assert_equal home_dir, created_file('home.dir'), :home_dir
        
      
        

          
          
          
        
      
        

          2
          
              env = created_file('env.vars')
        
      
        

          23
          
              env_vars = Hash[env.split("\n").map{ |line| line.split('=') }]
        
      
        

          2
          
              assert_equal  image_name, env_vars['CYBER_DOJO_IMAGE_NAME'], :cyber_dojo_image_name
        
      
        

          2
          
              assert_equal          id, env_vars['CYBER_DOJO_ID'], :cyber_dojo_id
        
      
        

          2
          
              assert_equal sandbox_dir, env_vars['CYBER_DOJO_SANDBOX'], :cyber_dojo_sandbox
        
      
        

          
          
          
        
      
        

          2
          
              assert_equal uid.to_s,     created_file('dir.stat.u'), :uid
        
      
        

          2
          
              assert_equal gid.to_s,     created_file('dir.stat.g'), :gid
        
      
        

          2
          
              assert_equal 'drwxrwxrwt', created_file('dir.stat.A'), :permission
        
      
        

          
          
          
        
      
        

          2
          
              expected_max_data_size  =  clang? ? 0 : 4 * GB / KB
        
      
        

          2
          
              expected_max_file_size  = 16 * MB / (block_size = 1024)
        
      
        

          2
          
              expected_max_stack_size =  8 * MB / KB
        
      
        

          2
          
              assert_equal expected_max_data_size,  ulimit(:data_size),  :data_size
        
      
        

          2
          
              assert_equal expected_max_file_size,  ulimit(:file_size),  :file_size
        
      
        

          2
          
              assert_equal expected_max_stack_size, ulimit(:stack_size), :stack_size
        
      
        

          2
          
              assert_equal 0,                       ulimit(:core_size),  :core_size
        
      
        

          2
          
              assert_equal 128,                     ulimit(:file_locks), :file_locks
        
      
        

          2
          
              assert_equal 256,                     ulimit(:open_files), :open_files
        
      
        

          2
          
              assert_equal 128,                     ulimit(:processes),  :processes
        
      
        

          
          
          
        
      
        

          2
          
              stats = files_stat
        
      
        

          2
          
              assert_equal starting_files.keys.sort, stats.keys.sort
        
      
        

          2
          
              starting_files.each do |filename, content|
        
      
        

          6
          
                if filename === 'cyber-dojo.sh'
        
      
        

          2
          
                  content = cyber_dojo_sh
        
      
        

          
          
                end
        
      
        

          6
          
                stat = stats[filename]
        
      
        

          6
          
                refute_nil stat, filename
        
      
        

          6
          
                diagnostic = { filename => stat }
        
      
        

          6
          
                assert_equal '-rw-r--r--', stat[:permissions], diagnostic
        
      
        

          6
          
                assert_equal          uid, stat[:uid        ], diagnostic
        
      
        

          6
          
                assert_equal        group, stat[:group      ], diagnostic
        
      
        

          6
          
                assert_equal content.size, stat[:size       ], diagnostic
        
      
        

          
          
                # On _default_ Alpine date-time file-stamps are to
        
      
        

          
          
                # the second granularity. In other words, the
        
      
        

          
          
                # microseconds value is always '000000000'.
        
      
        

          
          
                # Make sure this had been upgraded.
        
      
        

          6
          
                stamp = stat[:time] # eg '07:03:14.835233538'
        
      
        

          6
          
                microsecs = stamp.split(/[\:\.]/)[-1]
        
      
        

          6
          
                assert_equal 9, microsecs.length, :microsecs_length
        
      
        

          6
          
                refute_equal '0'*9, microsecs, :microsecs_not_zero
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            private
        
      
        

          
          
          
        
      
        

          1
          
            def home_dir
        
      
        

          2
          
              '/home/sandbox'
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def sandbox_dir
        
      
        

          28
          
              '/sandbox'
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def gid
        
      
        

          6
          
              51966
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            KB = 1024
        
      
        

          1
          
            MB = 1024 * KB
        
      
        

          1
          
            GB = 1024 * MB
        
      
        

          
          
          
        
      
        

          1
          
            def clang?
        
      
        

          2
          
              image_name.start_with?('cyberdojofoundation/clang')
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          
          
            ULIMIT_TABLE = {
        
      
        

          1
          
              :core_size  => 'core file size',
        
      
        

          
          
              :data_size  => 'data seg size',
        
      
        

          
          
              :file_locks => 'file locks',
        
      
        

          
          
              :file_size  => 'file size',
        
      
        

          
          
              :open_files => 'open files',
        
      
        

          
          
              :processes  => 'max user processes',
        
      
        

          
          
              :stack_size => 'stack size'
        
      
        

          
          
            }
        
      
        

          
          
          
        
      
        

          1
          
            def ulimit(key)
        
      
        

          14
          
              ulimit = created_file('ulimit.all')
        
      
        

          14
          
              text = ULIMIT_TABLE[key]
        
      
        

          14
          
              diagnostic = "#{ulimit}\nno ulimit for #{key}"
        
      
        

          14
          
              refute_nil text, diagnostic
        
      
        

          128
          
              entry = ulimit.lines.find { |line| line.start_with?(text) }
        
      
        

          14
          
              entry.split[-1].to_i
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            def files_stat
        
      
        

          2
          
              created_file('files.stat').lines.collect { |line|
        
      
        

          6
          
                attr = line.split
        
      
        

          6
          
                [attr[0], { # filename
        
      
        

          
          
                  permissions: attr[1],
        
      
        

          
          
                          uid: attr[2].to_i,
        
      
        

          
          
                        group: attr[3],
        
      
        

          
          
                         size: attr[4].to_i, # [5] === date
        
      
        

          
          
                         time: attr[6],
        
      
        

          
          
                }]
        
      
        

          
          
              }.to_h
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            def created_file(filename)
        
      
        

          32
          
              created[filename]['content']
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          
          
          # frozen_string_literal: true
        
      
        

          1
          
          require_relative 'test_base'
        
      
        

          
          
          
        
      
        

          1
          
          class LargeFileTruncationTest < TestBase
        
      
        

          
          
          
        
      
        

          1
          
            def self.id58_prefix
        
      
        

          12
          
              'E4A'
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            multi_os_test '52A',
        
      
        

          
          
            %w( generated text files bigger than 50K are truncated ) do
        
      
        

          2
          
              filename = 'large_file.txt'
        
      
        

          2
          
              script = "od -An -x /dev/urandom | head -c#{51*1024} > #{filename}"
        
      
        

          2
          
              script += ";stat -c%s #{filename}"
        
      
        

          2
          
              assert_cyber_dojo_sh(script)
        
      
        

          2
          
              assert_equal "#{51*1024}\n", stdout, :stdout
        
      
        

          2
          
              assert created[filename]['truncated'], :truncated
        
      
        

          2
          
              assert_equal 50*1024, created[filename]['content'].size, :size
        
      
        

          2
          
              assert_deleted([])
        
      
        

          2
          
              assert_changed({})
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            test '52B',
        
      
        

          
          
            %w( source files bigger than 10K are not truncated ) do
        
      
        

          1
          
              filename = 'Hiker.cs'
        
      
        

          1
          
              src = starting_files[filename]
        
      
        

          1
          
              large_comment = "/*#{'x'*10*1024}*/"
        
      
        

          1
          
              refute_nil src
        
      
        

          1
          
              run_cyber_dojo_sh( {
        
      
        

          
          
                changed:{
        
      
        

          
          
                  filename => src + large_comment
        
      
        

          
          
                }
        
      
        

          
          
              })
        
      
        

          1
          
              refute changed.keys.include?(filename)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          
          
          # frozen_string_literal: true
        
      
        

          1
          
          require_relative 'test_base'
        
      
        

          
          
          
        
      
        

          1
          
          class ReadyTest < TestBase
        
      
        

          
          
          
        
      
        

          1
          
            def self.id58_prefix
        
      
        

          4
          
              '872'
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            test '190', %w(
        
      
        

          
          
            ready? is true, useful for k8s readyness probes
        
      
        

          
          
            ) do
        
      
        

          1
          
              assert ready?
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          
          
          # frozen_string_literal: true
        
      
        

          1
          
          require_relative 'test_base'
        
      
        

          
          
          
        
      
        

          1
          
          class ReturnedTextFilesTest < TestBase
        
      
        

          
          
          
        
      
        

          1
          
            def self.id58_prefix
        
      
        

          72
          
              'ECF'
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            multi_os_test '524', %w(
        
      
        

          
          
            created text-file filenames are returned even when
        
      
        

          
          
            their names have leading hyphens which could easily
        
      
        

          
          
            be read as a tar-pipe option
        
      
        

          
          
            ) do
        
      
        

          2
          
              leading_hyphen = '-JPlOLNY7yt_fFndapHwIg'
        
      
        

          2
          
              script = "printf 'xxx' > '#{leading_hyphen}';"
        
      
        

          2
          
              assert_cyber_dojo_sh(script)
        
      
        

          2
          
              assert_created({leading_hyphen => intact('xxx')})
        
      
        

          2
          
              assert_deleted([])
        
      
        

          2
          
              assert_changed({})
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            multi_os_test '526', %w(
        
      
        

          
          
            created text files, including dot files, are returned
        
      
        

          
          
            ) do
        
      
        

          2
          
              script = [
        
      
        

          
          
                'printf "xxx" > newfile.txt',
        
      
        

          
          
                'printf "yyy" > .dotfile'
        
      
        

          
          
              ].join(';')
        
      
        

          2
          
              assert_cyber_dojo_sh(script)
        
      
        

          2
          
              assert_created({
        
      
        

          
          
                'newfile.txt' => intact('xxx'),
        
      
        

          
          
                '.dotfile' => intact('yyy')
        
      
        

          
          
              })
        
      
        

          2
          
              assert_deleted([])
        
      
        

          2
          
              assert_changed({})
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            multi_os_test '527', %w(
        
      
        

          
          
            created binary files are not returned
        
      
        

          
          
            ) do
        
      
        

          2
          
              script = [
        
      
        

          
          
                'dd if=/dev/zero of=binary.dat bs=1c count=42',
        
      
        

          
          
                'file --mime-encoding binary.dat'
        
      
        

          
          
              ].join(';')
        
      
        

          2
          
              assert_cyber_dojo_sh(script)
        
      
        

          2
          
              assert stdout.include?('binary.dat: binary')
        
      
        

          2
          
              assert_created({})
        
      
        

          2
          
              assert_deleted([])
        
      
        

          2
          
              assert_changed({})
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            multi_os_test '529', %w(
        
      
        

          
          
            text files created in sub-dirs are returned
        
      
        

          
          
            ) do
        
      
        

          2
          
              dirname = 'sub'
        
      
        

          2
          
              path = "#{dirname}/newfile.txt"
        
      
        

          2
          
              content = 'jjj'
        
      
        

          
          
              script = [
        
      
        

          2
          
                "mkdir #{dirname}",
        
      
        

          
          
                "printf '#{content}' > #{path}"
        
      
        

          
          
              ].join(';')
        
      
        

          2
          
              assert_cyber_dojo_sh(script)
        
      
        

          2
          
              assert_created({ path => intact(content) })
        
      
        

          2
          
              assert_deleted([])
        
      
        

          2
          
              assert_changed({})
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            multi_os_test '530', %w(
        
      
        

          
          
            deleted files are detected
        
      
        

          
          
            ) do
        
      
        

          2
          
              filename = any_src_file
        
      
        

          2
          
              script = "rm #{filename}"
        
      
        

          2
          
              assert_cyber_dojo_sh(script)
        
      
        

          2
          
              assert_created({})
        
      
        

          2
          
              assert_deleted([filename])
        
      
        

          2
          
              assert_changed({})
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            multi_os_test '531', %w(
        
      
        

          
          
            changed files are detected
        
      
        

          
          
            ) do
        
      
        

          2
          
              filename = any_src_file
        
      
        

          2
          
              content = 'XXX'
        
      
        

          2
          
              script = "printf '#{content}' > #{filename}"
        
      
        

          2
          
              assert_cyber_dojo_sh(script)
        
      
        

          2
          
              assert_created({})
        
      
        

          2
          
              assert_deleted([])
        
      
        

          2
          
              assert_changed({filename => intact(content)})
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            multi_os_test '532', %w(
        
      
        

          
          
            empty new text files are detected
        
      
        

          
          
            ) do
        
      
        

          
          
              # The file utility says empty files are binary files!
        
      
        

          2
          
              filename = 'empty.txt'
        
      
        

          2
          
              script = "touch #{filename}"
        
      
        

          2
          
              assert_cyber_dojo_sh(script)
        
      
        

          2
          
              assert_created({filename => intact('')})
        
      
        

          2
          
              assert_deleted([])
        
      
        

          2
          
              assert_changed({})
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            multi_os_test '533', %w(
        
      
        

          
          
            single-char new text files are detected
        
      
        

          
          
            ) do
        
      
        

          
          
              # The file utility says single-char files are binary files!
        
      
        

          2
          
              filename = 'one-char.txt'
        
      
        

          2
          
              ch = 'x'
        
      
        

          2
          
              script = "printf '#{ch}' > #{filename}"
        
      
        

          2
          
              assert_cyber_dojo_sh(script)
        
      
        

          2
          
              assert_created({filename => intact(ch)})
        
      
        

          2
          
              assert_deleted([])
        
      
        

          2
          
              assert_changed({})
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            multi_os_test '62C', %w(
        
      
        

          
          
            no text files under /sandbox at all, returns everything deleted
        
      
        

          
          
            ) do
        
      
        

          2
          
              assert_cyber_dojo_sh('rm -rf /sandbox/* /sandbox/.*')
        
      
        

          2
          
              assert_created({})
        
      
        

          2
          
              assert_deleted(manifest['visible_files'].keys.sort)
        
      
        

          2
          
              assert_changed({})
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            private # = = = = = = = = = = = = =
        
      
        

          
          
          
        
      
        

          1
          
            def any_src_file
        
      
        

          4
          
              manifest['visible_files'].keys.find do |filename|
        
      
        

          8
          
                filename.split('.')[0].upcase === 'HIKER'
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          
          
          # frozen_string_literal: true
        
      
        

          1
          
          require_relative 'test_base'
        
      
        

          
          
          
        
      
        

          1
          
          class SandboxSubDirTest < TestBase
        
      
        

          
          
          
        
      
        

          1
          
            def self.id58_prefix
        
      
        

          24
          
              'D8D'
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            multi_os_test '12A',
        
      
        

          
          
            'browser can create files in sandbox/ sub-dirs' do
        
      
        

          
          
              # The tar-pipe handles creating dir structure
        
      
        

          2
          
              assert_browser_can_create_files_in_sandbox_sub_dir('s1')
        
      
        

          2
          
              assert_browser_can_create_files_in_sandbox_sub_dir('s1/s2')
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            multi_os_test '12B',
        
      
        

          
          
            'cyber-dojo.sh can create files in sandbox/ sub-dirs' do
        
      
        

          2
          
              assert_cyber_dojo_sh_can_create_files_in_sandbox_sub_dir('d1')
        
      
        

          2
          
              assert_cyber_dojo_sh_can_create_files_in_sandbox_sub_dir('d1/d2/d3')
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            multi_os_test '12C',
        
      
        

          
          
            %w( cyber-dojo.sh can delete files from sandbox/ sub-dir ) do
        
      
        

          2
          
              assert_cyber_dojo_sh_can_delete_files_from_sandbox_sub_dir('c1')
        
      
        

          2
          
              assert_cyber_dojo_sh_can_delete_files_from_sandbox_sub_dir('c1/c2/c3')
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            private # = = = = = = = = = = = = = = = = = = = = = =
        
      
        

          
          
          
        
      
        

          1
          
            def assert_browser_can_create_files_in_sandbox_sub_dir(sub_dir)
        
      
        

          4
          
              filename = 'hello.txt'
        
      
        

          4
          
              content = 'the boy stood on the burning deck'
        
      
        

          4
          
              run_cyber_dojo_sh({
        
      
        

          
          
                created: { "#{sub_dir}/#{filename}" => content },
        
      
        

          
          
                changed: { 'cyber-dojo.sh' => "cd #{sub_dir} && #{stat_cmd}" }
        
      
        

          
          
              })
        
      
        

          4
          
              assert_stats(filename, '-rw-r--r--', content.length)
        
      
        

          4
          
              assert_equal({}, created, :created)
        
      
        

          4
          
              assert_equal({}, changed, :changed)
        
      
        

          4
          
              assert_equal([], deleted, :deleted)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            def assert_cyber_dojo_sh_can_create_files_in_sandbox_sub_dir(sub_dir)
        
      
        

          4
          
              filename = 'bonjour.txt'
        
      
        

          4
          
              content = 'xyzzy'
        
      
        

          
          
              cmd = [
        
      
        

          4
          
                "mkdir -p #{sub_dir}",
        
      
        

          
          
                "printf #{content} > #{sub_dir}/#{filename}",
        
      
        

          
          
                "cd #{sub_dir}",
        
      
        

          
          
                stat_cmd
        
      
        

          
          
              ].join(' && ')
        
      
        

          4
          
              run_cyber_dojo_sh({
        
      
        

          
          
                changed: { 'cyber-dojo.sh' => cmd }
        
      
        

          
          
              })
        
      
        

          4
          
              assert_stats(filename, '-rw-r--r--', content.length)
        
      
        

          
          
              expected = {
        
      
        

          4
          
                "#{sub_dir}/#{filename}" => {
        
      
        

          
          
                  'content' => content,
        
      
        

          
          
                  'truncated' => false
        
      
        

          
          
                }
        
      
        

          
          
              }
        
      
        

          4
          
              assert_equal(expected, created, :created)
        
      
        

          4
          
              assert_equal({}, changed, :changed)
        
      
        

          4
          
              assert_equal([], deleted, :deleted)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            def assert_cyber_dojo_sh_can_delete_files_from_sandbox_sub_dir(sub_dir)
        
      
        

          4
          
              filename = "#{sub_dir}/goodbye.txt"
        
      
        

          4
          
              content = 'goodbye, world'
        
      
        

          
          
              cmd = [
        
      
        

          4
          
                "rm #{filename}",
        
      
        

          
          
                "cd #{sub_dir}",
        
      
        

          
          
                stat_cmd
        
      
        

          
          
              ].join(' && ')
        
      
        

          4
          
              run_cyber_dojo_sh({
        
      
        

          
          
                created: { filename => content },
        
      
        

          
          
                changed: { 'cyber-dojo.sh' => cmd }
        
      
        

          
          
              })
        
      
        

          4
          
              assert_equal([], stdout_stats.keys, :keys)
        
      
        

          4
          
              assert_equal({}, created, :created)
        
      
        

          4
          
              assert_equal({}, changed, :changed)
        
      
        

          4
          
              assert_equal([filename], deleted, :deleted)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            def assert_stats(filename, permissions, size)
        
      
        

          8
          
              stats = stdout_stats[filename]
        
      
        

          8
          
              refute_nil stats, filename
        
      
        

          8
          
              diagnostic = { filename => stats }
        
      
        

          8
          
              assert_equal permissions, stats[:permissions], diagnostic
        
      
        

          8
          
              assert_equal uid, stats[:uid ], diagnostic
        
      
        

          8
          
              assert_equal group, stats[:group], diagnostic
        
      
        

          8
          
              assert_equal size, stats[:size ], diagnostic
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            def stdout_stats
        
      
        

          12
          
              stdout.lines.collect { |line|
        
      
        

          8
          
                attr = line.split
        
      
        

          8
          
                [attr[0], {         # filename eg hiker.h
        
      
        

          
          
                  permissions: attr[1],      # eg -rwxr--r--
        
      
        

          
          
                          uid: attr[2].to_i, # eg 40045
        
      
        

          
          
                        group: attr[3],      # eg cyber-dojo
        
      
        

          
          
                         size: attr[4].to_i, # eg 136
        
      
        

          
          
                   time_stamp: attr[6],      # eg 07:03:14.539952547
        
      
        

          
          
                }]
        
      
        

          
          
              }.to_h
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          
          
          # frozen_string_literal: true
        
      
        

          1
          
          require_relative 'test_base'
        
      
        

          
          
          
        
      
        

          1
          
          class ShaTest < TestBase
        
      
        

          
          
          
        
      
        

          1
          
            def self.id58_prefix
        
      
        

          4
          
              'FB3'
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            test '190', %w(
        
      
        

          
          
            sha of git commit which created docker image is available through API
        
      
        

          
          
            ) do
        
      
        

          1
          
              assert_sha(sha)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          
          
          # frozen_string_literal: true
        
      
        

          1
          
          require_relative 'test_base'
        
      
        

          
          
          
        
      
        

          1
          
          class TimedOutTest < TestBase
        
      
        

          
          
          
        
      
        

          1
          
            def self.id58_prefix
        
      
        

          12
          
              '9E9'
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            test 'B2A', %w(
        
      
        

          
          
            when timed_out is false,
        
      
        

          
          
            then the traffic-light colour is set
        
      
        

          
          
            ) do
        
      
        

          1
          
              run_cyber_dojo_sh
        
      
        

          1
          
              refute_timed_out
        
      
        

          1
          
              assert_equal 'red', colour, :colour
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            c_assert_test 'B2B', %w(
        
      
        

          
          
            when run_cyber_dojo_sh does not complete within max_seconds
        
      
        

          
          
            and does not produce output
        
      
        

          
          
            then stdout is empty,
        
      
        

          
          
            and timed_out is true,
        
      
        

          
          
            and the traffic-light colour is not set
        
      
        

          
          
            ) do
        
      
        

          
          
              named_args = {
        
      
        

          1
          
                changed: { 'hiker.c' => quiet_infinite_loop },
        
      
        

          
          
                max_seconds: 2
        
      
        

          
          
              }
        
      
        

          1
          
              with_captured_log {
        
      
        

          1
          
                run_cyber_dojo_sh(named_args)
        
      
        

          
          
              }
        
      
        

          1
          
              assert_timed_out
        
      
        

          1
          
              assert_equal '', stdout, :stdout
        
      
        

          1
          
              assert_equal '', stderr, :stderr
        
      
        

          1
          
              refute colour?, :colour?
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            c_assert_test '4D7', %w(
        
      
        

          
          
            when run_cyber_dojo_sh does not complete in max_seconds
        
      
        

          
          
            and produces output
        
      
        

          
          
            then stdout is not empty,
        
      
        

          
          
            and timed_out is true,
        
      
        

          
          
            and the traffic-light colour is not set
        
      
        

          
          
            ) do
        
      
        

          
          
              named_args = {
        
      
        

          1
          
                changed: { 'hiker.c' => loud_infinite_loop },
        
      
        

          
          
                max_seconds: 2
        
      
        

          
          
              }
        
      
        

          1
          
              with_captured_log {
        
      
        

          1
          
                run_cyber_dojo_sh(named_args)
        
      
        

          
          
              }
        
      
        

          1
          
              assert_timed_out
        
      
        

          1
          
              refute_equal '', stdout, :stdout
        
      
        

          1
          
              refute colour?, :colour?
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            private
        
      
        

          
          
          
        
      
        

          1
          
            def colour?
        
      
        

          2
          
              result.has_key?('colour')
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            def quiet_infinite_loop
        
      
        

          1
          
              <<~SOURCE
        
      
        

          
          
              #include "hiker.h"
        
      
        

          
          
              int answer(void)
        
      
        

          
          
              {
        
      
        

          
          
                  for(;;);
        
      
        

          
          
                  return 6 * 7;
        
      
        

          
          
              }
        
      
        

          
          
              SOURCE
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            def loud_infinite_loop
        
      
        

          1
          
              <<~SOURCE
        
      
        

          
          
              #include "hiker.h"
        
      
        

          
          
              #include <stdio.h>
        
      
        

          
          
              int answer(void)
        
      
        

          
          
              {
        
      
        

          
          
                  for(;;)
        
      
        

          
          
                      puts("Hello");
        
      
        

          
          
                  return 6 * 7;
        
      
        

          
          
              }
        
      
        

          
          
              SOURCE
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          
          
          # frozen_string_literal: true
        
      
        

          1
          
          require_relative 'test_base'
        
      
        

          1
          
          require 'tmpdir'
        
      
        

          
          
          
        
      
        

          1
          
          class TrafficLightTest < TestBase
        
      
        

          
          
          
        
      
        

          1
          
            def self.id58_prefix
        
      
        

          68
          
              '7B7'
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            multi_os_test '9DA', %w( stdout is not being whitespace stripped ) do
        
      
        

          2
          
              stdout = assert_cyber_dojo_sh('printf " hello \n"')
        
      
        

          2
          
              assert_equal " hello \n", stdout
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            multi_os_test '9DB', %w( red traffic-light, no diagnostics ) do
        
      
        

          2
          
              run_cyber_dojo_sh
        
      
        

          2
          
              assert_equal 'red', colour, :colour
        
      
        

          2
          
              assert_nil diagnostic, :diagnostic
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            multi_os_test '9DC', %w( amber traffic-light, no diagnostics ) do
        
      
        

          2
          
              syntax_error = starting_files[filename_6x9].sub('6 * 9', '6 * 9sdf')
        
      
        

          2
          
              run_cyber_dojo_sh({changed:{filename_6x9=>syntax_error}})
        
      
        

          2
          
              assert_equal 'amber', colour, :colour
        
      
        

          2
          
              assert_nil diagnostic, :diagnostic
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            multi_os_test '9DD', %w( green traffic-light, no diagnostics ) do
        
      
        

          2
          
              passing = starting_files[filename_6x9].sub('6 * 9', '6 * 7')
        
      
        

          2
          
              run_cyber_dojo_sh({changed:{filename_6x9=>passing}})
        
      
        

          2
          
              assert_equal 'green', colour, :colour
        
      
        

          2
          
              assert_nil diagnostic, :diagnostic
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            test '421', %w(
        
      
        

          
          
            when rag-lambda is missing,
        
      
        

          
          
            then the colour is faulty,
        
      
        

          
          
            and diagnostics are added to the json result
        
      
        

          
          
            ) do
        
      
        

          1
          
              image_stub = "runner_test_stub:#{id}"
        
      
        

          1
          
              Dir.mktmpdir do |dir|
        
      
        

          
          
                dockerfile = [
        
      
        

          1
          
                  "FROM #{image_name}",
        
      
        

          
          
                  'RUN rm /usr/local/bin/red_amber_green.rb'
        
      
        

          
          
                ].join("\n")
        
      
        

          1
          
                IO.write("#{dir}/Dockerfile", dockerfile)
        
      
        

          1
          
                shell.assert("docker build --tag #{image_stub} #{dir}")
        
      
        

          
          
              end
        
      
        

          
          
              begin
        
      
        

          1
          
                run_cyber_dojo_sh({image_name:image_stub})
        
      
        

          1
          
                expected_info = "no /usr/local/bin/red_amber_green.rb in #{image_stub}"
        
      
        

          1
          
                assert_equal 'faulty', colour
        
      
        

          1
          
                assert_equal image_stub, diagnostic['image_name'], :image_name
        
      
        

          1
          
                assert_equal id, diagnostic['id'], :id
        
      
        

          1
          
                assert_equal expected_info, diagnostic['info'], :info
        
      
        

          1
          
                assert_nil diagnostic['name'], :name
        
      
        

          1
          
                assert_nil diagnostic['message'], :message
        
      
        

          1
          
                assert_nil diagnostic['rag_lambda'], :rag_lambda
        
      
        

          
          
              ensure
        
      
        

          1
          
                shell.assert("docker image rm #{image_stub}")
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            test '422', %w(
        
      
        

          
          
            when rag-lambda has an eval exception,
        
      
        

          
          
            then the colour is faulty,
        
      
        

          
          
            and diagnostics are added to the json result
        
      
        

          
          
            ) do
        
      
        

          
          
              stub =
        
      
        

          1
          
                <<~RUBY
        
      
        

          
          
                sdf
        
      
        

          
          
                RUBY
        
      
        

          1
          
              image_stub = run_cyber_dojo_image_stubbed_with(stub)
        
      
        

          1
          
              expected_info = 'eval(rag_lambda) raised an exception'
        
      
        

          1
          
              expected_message = "undefined local variable or method `sdf'"
        
      
        

          1
          
              assert_equal 'faulty', colour, :colour
        
      
        

          1
          
              assert_equal image_stub, diagnostic['image_name'], :image_name
        
      
        

          1
          
              assert_equal id, diagnostic['id'], :id
        
      
        

          1
          
              assert_equal expected_info, diagnostic['info'], :info
        
      
        

          1
          
              assert_equal 'NameError', diagnostic['name'], :name
        
      
        

          1
          
              assert diagnostic['message'][0].start_with?(expected_message), :message
        
      
        

          1
          
              assert_equal stub.split("\n"), diagnostic['rag_lambda'], :rag_lambda
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            test '423', %w(
        
      
        

          
          
            when rag-lambda has a call exception,
        
      
        

          
          
            then the colour is faulty,
        
      
        

          
          
            and diagnostics are added to the json result
        
      
        

          
          
            ) do
        
      
        

          
          
              stub =
        
      
        

          1
          
                <<~RUBY
        
      
        

          
          
                lambda { |stdout, stderr, status|
        
      
        

          
          
                  raise ArgumentError.new('wibble')
        
      
        

          
          
                }
        
      
        

          
          
                RUBY
        
      
        

          1
          
              image_stub = run_cyber_dojo_image_stubbed_with(stub)
        
      
        

          1
          
              expected_info = 'rag_lambda.call raised an exception'
        
      
        

          1
          
              assert_equal 'faulty', colour, :colour
        
      
        

          1
          
              assert_equal image_stub, diagnostic['image_name'], :image_name
        
      
        

          1
          
              assert_equal id, diagnostic['id'], :id
        
      
        

          1
          
              assert_equal expected_info, diagnostic['info'], :info
        
      
        

          1
          
              assert_equal 'ArgumentError', diagnostic['name'], :name
        
      
        

          1
          
              assert_equal ['wibble'], diagnostic['message'], :message
        
      
        

          1
          
              assert_equal stub.split("\n"), diagnostic['rag_lambda'], :rag_lambda
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            test '424', %w(
        
      
        

          
          
            when the rag-lambda returns non red/amber/green,
        
      
        

          
          
            then the colour is faulty,
        
      
        

          
          
            and diagnostics are added to the json result
        
      
        

          
          
            ) do
        
      
        

          
          
              stub =
        
      
        

          1
          
              <<~RUBY
        
      
        

          
          
              lambda { |stdout, stderr, status|
        
      
        

          
          
                return :orange
        
      
        

          
          
              }
        
      
        

          
          
              RUBY
        
      
        

          1
          
              image_stub = run_cyber_dojo_image_stubbed_with(stub)
        
      
        

          1
          
              expected_info = "rag_lambda.call is 'orange' which is not 'red'|'amber'|'green'"
        
      
        

          1
          
              assert_equal 'faulty', colour, :colour
        
      
        

          1
          
              assert_equal image_stub, diagnostic['image_name'], :image_name
        
      
        

          1
          
              assert_equal id, diagnostic['id'], :id
        
      
        

          1
          
              assert_equal expected_info, diagnostic['info'], :info
        
      
        

          1
          
              assert_nil diagnostic['name'], :name
        
      
        

          1
          
              assert_nil diagnostic['message'], :message
        
      
        

          1
          
              assert_equal stub.split("\n"), diagnostic['rag_lambda'], :rag_lambda
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            test '425', %w(
        
      
        

          
          
            when the rag-lambda has too few parameters,
        
      
        

          
          
            then the colour is faulty,
        
      
        

          
          
            and diagnostics are added to the json result
        
      
        

          
          
            ) do
        
      
        

          
          
              stub =
        
      
        

          1
          
              <<~RUBY
        
      
        

          
          
              lambda { |stdout, stderr|
        
      
        

          
          
                return :red
        
      
        

          
          
              }
        
      
        

          
          
              RUBY
        
      
        

          1
          
              image_stub = run_cyber_dojo_image_stubbed_with(stub)
        
      
        

          1
          
              expected_info = 'rag_lambda.call raised an exception'
        
      
        

          1
          
              expected_message = 'wrong number of arguments (given 3, expected 2)'
        
      
        

          1
          
              assert_equal 'faulty', colour, :colour
        
      
        

          1
          
              assert_equal image_stub, diagnostic['image_name'], :image_name
        
      
        

          1
          
              assert_equal id, diagnostic['id'], :id
        
      
        

          1
          
              assert_equal expected_info, diagnostic['info'], :info
        
      
        

          1
          
              assert_equal 'ArgumentError', diagnostic['name'], :name
        
      
        

          1
          
              assert_equal [expected_message], diagnostic['message'], :message
        
      
        

          1
          
              assert_equal stub.split("\n"), diagnostic['rag_lambda'], :rag_lambda
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            test '426', %w(
        
      
        

          
          
            when the rag-lambda has too many parameters,
        
      
        

          
          
            then the colour is faulty,
        
      
        

          
          
            and diagnostics are added to the json result
        
      
        

          
          
            ) do
        
      
        

          
          
              stub =
        
      
        

          1
          
              <<~RUBY
        
      
        

          
          
              lambda { |stdout, stderr, status, extra|
        
      
        

          
          
                return :red
        
      
        

          
          
              }
        
      
        

          
          
              RUBY
        
      
        

          1
          
              image_stub = run_cyber_dojo_image_stubbed_with(stub)
        
      
        

          1
          
              expected_info = 'rag_lambda.call raised an exception'
        
      
        

          1
          
              expected_message = 'wrong number of arguments (given 3, expected 4)'
        
      
        

          1
          
              assert_equal 'faulty', colour, :colour
        
      
        

          1
          
              assert_equal image_stub, diagnostic['image_name'], :image_name
        
      
        

          1
          
              assert_equal id, diagnostic['id'], :id
        
      
        

          1
          
              assert_equal expected_info, diagnostic['info'], :info
        
      
        

          1
          
              assert_equal 'ArgumentError', diagnostic['name'], :name
        
      
        

          1
          
              assert_equal [expected_message], diagnostic['message'], :message
        
      
        

          1
          
              assert_equal stub.split("\n"), diagnostic['rag_lambda'], :rag_lambda
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            test '427', %w(
        
      
        

          
          
            when the rag-lambda has an eval SyntaxError exception,
        
      
        

          
          
            then the colour is faulty,
        
      
        

          
          
            and diagnostics are added to the json result
        
      
        

          
          
            ) do
        
      
        

          1
          
              stub = 'return :red adsd'
        
      
        

          1
          
              image_stub = run_cyber_dojo_image_stubbed_with(stub)
        
      
        

          1
          
              expected_info = 'eval(rag_lambda) raised an exception'
        
      
        

          1
          
              expected_message = 'syntax error, unexpected tIDENTIFIER'
        
      
        

          1
          
              assert_equal 'faulty', colour, :colour
        
      
        

          1
          
              assert_equal image_stub, diagnostic['image_name'], :image_name
        
      
        

          1
          
              assert_equal id, diagnostic['id'], :id
        
      
        

          1
          
              assert_equal expected_info, diagnostic['info'], :info
        
      
        

          1
          
              assert_equal 'SyntaxError', diagnostic['name'], :name
        
      
        

          1
          
              assert diagnostic['message'][0].include?(expected_message), :message
        
      
        

          1
          
              assert_equal stub.split("\n"), diagnostic['rag_lambda'], :rag_lambda
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            test '428', %w(
        
      
        

          
          
            when the rag-lambda raises an Exception directly,
        
      
        

          
          
            then the colour is faulty,
        
      
        

          
          
            and diagnostics are added to the json result
        
      
        

          
          
            ) do
        
      
        

          1
          
              stub = 'raise Exception, "fubar"'
        
      
        

          1
          
              image_stub = run_cyber_dojo_image_stubbed_with(stub)
        
      
        

          1
          
              expected_info = 'eval(rag_lambda) raised an exception'
        
      
        

          1
          
              assert_equal 'faulty', colour, :colour
        
      
        

          1
          
              assert_equal image_stub, diagnostic['image_name'], :image_name
        
      
        

          1
          
              assert_equal id, diagnostic['id'], :id
        
      
        

          1
          
              assert_equal expected_info, diagnostic['info'], :info
        
      
        

          1
          
              assert_equal 'Exception', diagnostic['name'], :name
        
      
        

          1
          
              assert_equal ['fubar'], diagnostic['message'], :message
        
      
        

          1
          
              assert_equal stub.split("\n"), diagnostic['rag_lambda'], :rag_lambda
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            test '429', %w(
        
      
        

          
          
            when the base-os is Ubuntu 16.04,
        
      
        

          
          
            then the colour is faulty,
        
      
        

          
          
            and diagnostics are added to the json result,
        
      
        

          
          
            stating the file command was not found,
        
      
        

          
          
            stating --verbatim-files-from is an unrecognized tar option
        
      
        

          
          
            ) do
        
      
        

          1
          
              log = with_captured_log {
        
      
        

          1
          
                run_cyber_dojo_sh({image_name:'ubuntu:16.04'})
        
      
        

          
          
              }
        
      
        

          1
          
              assert_equal 'faulty', colour, :colour
        
      
        

          1
          
              no_file_msg = 'bash: file: command not found'
        
      
        

          1
          
              no_tar_verbatim_msg = "tar: unrecognized option '--verbatim-files-from'"
        
      
        

          1
          
              assert log.include?(no_file_msg), log
        
      
        

          1
          
              assert diagnostic['stderr'].include?(no_file_msg), diagnostic
        
      
        

          1
          
              assert log.include?(no_tar_verbatim_msg), log
        
      
        

          1
          
              assert diagnostic['stderr'].include?(no_tar_verbatim_msg), diagnostic
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            private
        
      
        

          
          
          
        
      
        

          1
          
            def filename_6x9
        
      
        

          8
          
              starting_files.keys.find { |filename|
        
      
        

          16
          
                starting_files[filename].include?('6 * 9')
        
      
        

          
          
              }
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # - - - - - - - - - - - - - - - - -
        
      
        

          
          
          
        
      
        

          1
          
            def run_cyber_dojo_image_stubbed_with(stub)
        
      
        

          7
          
              image_stub = "runner_test_stub:#{id}"
        
      
        

          7
          
              Dir.mktmpdir do |dir|
        
      
        

          
          
                dockerfile = [
        
      
        

          7
          
                  "FROM #{image_name}",
        
      
        

          
          
                  'COPY stub /usr/local/bin/red_amber_green.rb'
        
      
        

          
          
                ].join("\n")
        
      
        

          7
          
                IO.write("#{dir}/stub", stub)
        
      
        

          7
          
                IO.write("#{dir}/Dockerfile", dockerfile)
        
      
        

          7
          
                shell.assert("docker build --tag #{image_stub} #{dir}")
        
      
        

          
          
              end
        
      
        

          
          
              begin
        
      
        

          7
          
                run_cyber_dojo_sh({image_name:image_stub})
        
      
        

          7
          
                image_stub
        
      
        

          
          
              ensure
        
      
        

          7
          
                shell.assert("docker image rm #{image_stub}")
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          end